mirror of
https://github.com/MultiMC/MultiMC5.git
synced 2024-10-06 06:50:16 +00:00
NOISSUE include a static build of zlib
This commit is contained in:
parent
7643a7cc45
commit
21e453814b
@ -54,7 +54,7 @@ set(CMAKE_JAVA_TARGET_OUTPUT_DIR ${PROJECT_BINARY_DIR}/jars)
|
|||||||
|
|
||||||
######## Set compiler flags ########
|
######## Set compiler flags ########
|
||||||
include(GenerateExportHeader)
|
include(GenerateExportHeader)
|
||||||
set(CMAKE_CXX_FLAGS " -Wall -pedantic -Werror -Wno-deprecated-declarations -Wno-gnu-zero-variadic-macro-arguments -fstack-protector-strong --param=ssp-buffer-size=4 ${CMAKE_CXX_FLAGS}")
|
set(CMAKE_CXX_FLAGS " -Wall -pedantic -fstack-protector-strong --param=ssp-buffer-size=4 ${CMAKE_CXX_FLAGS}")
|
||||||
set(CMAKE_CXX_FLAGS_RELEASE " -O3 -D_FORTIFY_SOURCE=2 ${CMAKE_CXX_FLAGS_RELEASE}")
|
set(CMAKE_CXX_FLAGS_RELEASE " -O3 -D_FORTIFY_SOURCE=2 ${CMAKE_CXX_FLAGS_RELEASE}")
|
||||||
if(UNIX AND APPLE)
|
if(UNIX AND APPLE)
|
||||||
set(CMAKE_CXX_FLAGS " -stdlib=libc++ ${CMAKE_CXX_FLAGS}")
|
set(CMAKE_CXX_FLAGS " -stdlib=libc++ ${CMAKE_CXX_FLAGS}")
|
||||||
@ -182,6 +182,7 @@ add_subdirectory(libraries/hoedown) # markdown parser
|
|||||||
add_subdirectory(libraries/launcher) # java based launcher part for Minecraft
|
add_subdirectory(libraries/launcher) # java based launcher part for Minecraft
|
||||||
add_subdirectory(libraries/javacheck) # java compatibility checker
|
add_subdirectory(libraries/javacheck) # java compatibility checker
|
||||||
add_subdirectory(libraries/xz-embedded) # xz compression
|
add_subdirectory(libraries/xz-embedded) # xz compression
|
||||||
|
add_subdirectory(libraries/zlib) # a suitable copy of zlib
|
||||||
add_subdirectory(libraries/quazip) # zip manipulation library
|
add_subdirectory(libraries/quazip) # zip manipulation library
|
||||||
add_subdirectory(libraries/rainbow) # Qt extension for colors
|
add_subdirectory(libraries/rainbow) # Qt extension for colors
|
||||||
add_subdirectory(libraries/iconfix) # fork of Qt's QIcon loader
|
add_subdirectory(libraries/iconfix) # fork of Qt's QIcon loader
|
||||||
|
@ -540,9 +540,6 @@ add_unit_test(Index
|
|||||||
|
|
||||||
################################ COMPILE ################################
|
################################ COMPILE ################################
|
||||||
|
|
||||||
# we need zlib
|
|
||||||
find_package(ZLIB REQUIRED)
|
|
||||||
|
|
||||||
set(LOGIC_SOURCES
|
set(LOGIC_SOURCES
|
||||||
${CORE_SOURCES}
|
${CORE_SOURCES}
|
||||||
${PATHMATCHER_SOURCES}
|
${PATHMATCHER_SOURCES}
|
||||||
@ -917,7 +914,7 @@ target_link_libraries(Launcher_logic
|
|||||||
Launcher_quazip
|
Launcher_quazip
|
||||||
Launcher_classparser
|
Launcher_classparser
|
||||||
${NBT_NAME}
|
${NBT_NAME}
|
||||||
${ZLIB_LIBRARIES}
|
zlibstatic
|
||||||
optional-bare
|
optional-bare
|
||||||
tomlc99
|
tomlc99
|
||||||
BuildConfig
|
BuildConfig
|
||||||
|
@ -1 +1 @@
|
|||||||
Subproject commit 5f3a4ec7a4b354688056d6f13c1cdd907a250a12
|
Subproject commit b318840e7cb0ec476aaa44737b51ec4e7efd27c9
|
26
libraries/zlib/.gitignore
vendored
Normal file
26
libraries/zlib/.gitignore
vendored
Normal file
@ -0,0 +1,26 @@
|
|||||||
|
*.diff
|
||||||
|
*.patch
|
||||||
|
*.orig
|
||||||
|
*.rej
|
||||||
|
|
||||||
|
*~
|
||||||
|
*.a
|
||||||
|
*.lo
|
||||||
|
*.o
|
||||||
|
*.dylib
|
||||||
|
|
||||||
|
*.gcda
|
||||||
|
*.gcno
|
||||||
|
*.gcov
|
||||||
|
|
||||||
|
/example
|
||||||
|
/example64
|
||||||
|
/examplesh
|
||||||
|
/libz.so*
|
||||||
|
/minigzip
|
||||||
|
/minigzip64
|
||||||
|
/minigzipsh
|
||||||
|
/zlib.pc
|
||||||
|
/configure.log
|
||||||
|
|
||||||
|
.DS_Store
|
139
libraries/zlib/CMakeLists.txt
Normal file
139
libraries/zlib/CMakeLists.txt
Normal file
@ -0,0 +1,139 @@
|
|||||||
|
cmake_minimum_required(VERSION 3.1)
|
||||||
|
|
||||||
|
project(zlib C)
|
||||||
|
|
||||||
|
set(VERSION "1.2.12")
|
||||||
|
|
||||||
|
option(ASM686 "Enable building i686 assembly implementation")
|
||||||
|
option(AMD64 "Enable building amd64 assembly implementation")
|
||||||
|
|
||||||
|
include(CheckTypeSize)
|
||||||
|
include(CheckFunctionExists)
|
||||||
|
include(CheckIncludeFile)
|
||||||
|
include(CheckCSourceCompiles)
|
||||||
|
|
||||||
|
check_include_file(sys/types.h HAVE_SYS_TYPES_H)
|
||||||
|
check_include_file(stdint.h HAVE_STDINT_H)
|
||||||
|
check_include_file(stddef.h HAVE_STDDEF_H)
|
||||||
|
|
||||||
|
#
|
||||||
|
# Check to see if we have large file support
|
||||||
|
#
|
||||||
|
set(CMAKE_REQUIRED_DEFINITIONS -D_LARGEFILE64_SOURCE=1)
|
||||||
|
# We add these other definitions here because CheckTypeSize.cmake
|
||||||
|
# in CMake 2.4.x does not automatically do so and we want
|
||||||
|
# compatibility with CMake 2.4.x.
|
||||||
|
if(HAVE_SYS_TYPES_H)
|
||||||
|
list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_SYS_TYPES_H)
|
||||||
|
endif()
|
||||||
|
if(HAVE_STDINT_H)
|
||||||
|
list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDINT_H)
|
||||||
|
endif()
|
||||||
|
if(HAVE_STDDEF_H)
|
||||||
|
list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDDEF_H)
|
||||||
|
endif()
|
||||||
|
check_type_size(off64_t OFF64_T)
|
||||||
|
if(HAVE_OFF64_T)
|
||||||
|
add_definitions(-D_LARGEFILE64_SOURCE=1)
|
||||||
|
endif()
|
||||||
|
set(CMAKE_REQUIRED_DEFINITIONS) # clear variable
|
||||||
|
|
||||||
|
#
|
||||||
|
# Check for fseeko
|
||||||
|
#
|
||||||
|
check_function_exists(fseeko HAVE_FSEEKO)
|
||||||
|
if(NOT HAVE_FSEEKO)
|
||||||
|
add_definitions(-DNO_FSEEKO)
|
||||||
|
endif()
|
||||||
|
|
||||||
|
#
|
||||||
|
# Check for unistd.h
|
||||||
|
#
|
||||||
|
check_include_file(unistd.h Z_HAVE_UNISTD_H)
|
||||||
|
|
||||||
|
if(MSVC)
|
||||||
|
set(CMAKE_DEBUG_POSTFIX "d")
|
||||||
|
add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
|
||||||
|
add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
|
||||||
|
endif()
|
||||||
|
|
||||||
|
configure_file(
|
||||||
|
${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.cmakein
|
||||||
|
${CMAKE_CURRENT_BINARY_DIR}/zconf.h
|
||||||
|
@ONLY
|
||||||
|
)
|
||||||
|
|
||||||
|
#============================================================================
|
||||||
|
# zlib
|
||||||
|
#============================================================================
|
||||||
|
|
||||||
|
set(ZLIB_PUBLIC_HDRS
|
||||||
|
${CMAKE_CURRENT_BINARY_DIR}/zconf.h
|
||||||
|
zlib.h
|
||||||
|
)
|
||||||
|
set(ZLIB_PRIVATE_HDRS
|
||||||
|
crc32.h
|
||||||
|
deflate.h
|
||||||
|
gzguts.h
|
||||||
|
inffast.h
|
||||||
|
inffixed.h
|
||||||
|
inflate.h
|
||||||
|
inftrees.h
|
||||||
|
trees.h
|
||||||
|
zutil.h
|
||||||
|
)
|
||||||
|
set(ZLIB_SRCS
|
||||||
|
adler32.c
|
||||||
|
compress.c
|
||||||
|
crc32.c
|
||||||
|
deflate.c
|
||||||
|
gzclose.c
|
||||||
|
gzlib.c
|
||||||
|
gzread.c
|
||||||
|
gzwrite.c
|
||||||
|
inflate.c
|
||||||
|
infback.c
|
||||||
|
inftrees.c
|
||||||
|
inffast.c
|
||||||
|
trees.c
|
||||||
|
uncompr.c
|
||||||
|
zutil.c
|
||||||
|
)
|
||||||
|
|
||||||
|
if(CMAKE_COMPILER_IS_GNUCC)
|
||||||
|
if(ASM686)
|
||||||
|
set(ZLIB_ASMS contrib/asm686/match.S)
|
||||||
|
elseif (AMD64)
|
||||||
|
set(ZLIB_ASMS contrib/amd64/amd64-match.S)
|
||||||
|
endif ()
|
||||||
|
|
||||||
|
if(ZLIB_ASMS)
|
||||||
|
add_definitions(-DASMV)
|
||||||
|
set_source_files_properties(${ZLIB_ASMS} PROPERTIES LANGUAGE C COMPILE_FLAGS -DNO_UNDERLINE)
|
||||||
|
endif()
|
||||||
|
endif()
|
||||||
|
|
||||||
|
if(MSVC)
|
||||||
|
if(ASM686)
|
||||||
|
ENABLE_LANGUAGE(ASM_MASM)
|
||||||
|
set(ZLIB_ASMS
|
||||||
|
contrib/masmx86/inffas32.asm
|
||||||
|
contrib/masmx86/match686.asm
|
||||||
|
)
|
||||||
|
elseif (AMD64)
|
||||||
|
ENABLE_LANGUAGE(ASM_MASM)
|
||||||
|
set(ZLIB_ASMS
|
||||||
|
contrib/masmx64/gvmat64.asm
|
||||||
|
contrib/masmx64/inffasx64.asm
|
||||||
|
)
|
||||||
|
endif()
|
||||||
|
|
||||||
|
if(ZLIB_ASMS)
|
||||||
|
add_definitions(-DASMV -DASMINF)
|
||||||
|
endif()
|
||||||
|
endif()
|
||||||
|
|
||||||
|
add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
|
||||||
|
set_target_properties(zlibstatic PROPERTIES OUTPUT_NAME z)
|
||||||
|
set_property(TARGET zlibstatic PROPERTY POSITION_INDEPENDENT_CODE ON)
|
||||||
|
target_include_directories(zlibstatic PUBLIC ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR})
|
118
libraries/zlib/README
Normal file
118
libraries/zlib/README
Normal file
@ -0,0 +1,118 @@
|
|||||||
|
ZLIB DATA COMPRESSION LIBRARY
|
||||||
|
|
||||||
|
zlib 1.2.12 is a general purpose data compression library. All the code is
|
||||||
|
thread safe. The data format used by the zlib library is described by RFCs
|
||||||
|
(Request for Comments) 1950 to 1952 in the files
|
||||||
|
http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and
|
||||||
|
rfc1952 (gzip format).
|
||||||
|
|
||||||
|
All functions of the compression library are documented in the file zlib.h
|
||||||
|
(volunteer to write man pages welcome, contact zlib@gzip.org). A usage example
|
||||||
|
of the library is given in the file test/example.c which also tests that
|
||||||
|
the library is working correctly. Another example is given in the file
|
||||||
|
test/minigzip.c. The compression library itself is composed of all source
|
||||||
|
files in the root directory.
|
||||||
|
|
||||||
|
To compile all files and run the test program, follow the instructions given at
|
||||||
|
the top of Makefile.in. In short "./configure; make test", and if that goes
|
||||||
|
well, "make install" should work for most flavors of Unix. For Windows, use
|
||||||
|
one of the special makefiles in win32/ or contrib/vstudio/ . For VMS, use
|
||||||
|
make_vms.com.
|
||||||
|
|
||||||
|
Questions about zlib should be sent to <zlib@gzip.org>, or to Gilles Vollant
|
||||||
|
<info@winimage.com> for the Windows DLL version. The zlib home page is
|
||||||
|
http://zlib.net/ . Before reporting a problem, please check this site to
|
||||||
|
verify that you have the latest version of zlib; otherwise get the latest
|
||||||
|
version and check whether the problem still exists or not.
|
||||||
|
|
||||||
|
PLEASE read the zlib FAQ http://zlib.net/zlib_faq.html before asking for help.
|
||||||
|
|
||||||
|
Mark Nelson <markn@ieee.org> wrote an article about zlib for the Jan. 1997
|
||||||
|
issue of Dr. Dobb's Journal; a copy of the article is available at
|
||||||
|
http://marknelson.us/1997/01/01/zlib-engine/ .
|
||||||
|
|
||||||
|
The changes made in version 1.2.12 are documented in the file ChangeLog.
|
||||||
|
|
||||||
|
Unsupported third party contributions are provided in directory contrib/ .
|
||||||
|
|
||||||
|
zlib is available in Java using the java.util.zip package, documented at
|
||||||
|
http://java.sun.com/developer/technicalArticles/Programming/compression/ .
|
||||||
|
|
||||||
|
A Perl interface to zlib written by Paul Marquess <pmqs@cpan.org> is available
|
||||||
|
at CPAN (Comprehensive Perl Archive Network) sites, including
|
||||||
|
http://search.cpan.org/~pmqs/IO-Compress-Zlib/ .
|
||||||
|
|
||||||
|
A Python interface to zlib written by A.M. Kuchling <amk@amk.ca> is
|
||||||
|
available in Python 1.5 and later versions, see
|
||||||
|
http://docs.python.org/library/zlib.html .
|
||||||
|
|
||||||
|
zlib is built into tcl: http://wiki.tcl.tk/4610 .
|
||||||
|
|
||||||
|
An experimental package to read and write files in .zip format, written on top
|
||||||
|
of zlib by Gilles Vollant <info@winimage.com>, is available in the
|
||||||
|
contrib/minizip directory of zlib.
|
||||||
|
|
||||||
|
|
||||||
|
Notes for some targets:
|
||||||
|
|
||||||
|
- For Windows DLL versions, please see win32/DLL_FAQ.txt
|
||||||
|
|
||||||
|
- For 64-bit Irix, deflate.c must be compiled without any optimization. With
|
||||||
|
-O, one libpng test fails. The test works in 32 bit mode (with the -n32
|
||||||
|
compiler flag). The compiler bug has been reported to SGI.
|
||||||
|
|
||||||
|
- zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1 it works
|
||||||
|
when compiled with cc.
|
||||||
|
|
||||||
|
- On Digital Unix 4.0D (formely OSF/1) on AlphaServer, the cc option -std1 is
|
||||||
|
necessary to get gzprintf working correctly. This is done by configure.
|
||||||
|
|
||||||
|
- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works with
|
||||||
|
other compilers. Use "make test" to check your compiler.
|
||||||
|
|
||||||
|
- gzdopen is not supported on RISCOS or BEOS.
|
||||||
|
|
||||||
|
- For PalmOs, see http://palmzlib.sourceforge.net/
|
||||||
|
|
||||||
|
|
||||||
|
Acknowledgments:
|
||||||
|
|
||||||
|
The deflate format used by zlib was defined by Phil Katz. The deflate and
|
||||||
|
zlib specifications were written by L. Peter Deutsch. Thanks to all the
|
||||||
|
people who reported problems and suggested various improvements in zlib; they
|
||||||
|
are too numerous to cite here.
|
||||||
|
|
||||||
|
Copyright notice:
|
||||||
|
|
||||||
|
(C) 1995-2022 Jean-loup Gailly and Mark Adler
|
||||||
|
|
||||||
|
This software is provided 'as-is', without any express or implied
|
||||||
|
warranty. In no event will the authors be held liable for any damages
|
||||||
|
arising from the use of this software.
|
||||||
|
|
||||||
|
Permission is granted to anyone to use this software for any purpose,
|
||||||
|
including commercial applications, and to alter it and redistribute it
|
||||||
|
freely, subject to the following restrictions:
|
||||||
|
|
||||||
|
1. The origin of this software must not be misrepresented; you must not
|
||||||
|
claim that you wrote the original software. If you use this software
|
||||||
|
in a product, an acknowledgment in the product documentation would be
|
||||||
|
appreciated but is not required.
|
||||||
|
2. Altered source versions must be plainly marked as such, and must not be
|
||||||
|
misrepresented as being the original software.
|
||||||
|
3. This notice may not be removed or altered from any source distribution.
|
||||||
|
|
||||||
|
Jean-loup Gailly Mark Adler
|
||||||
|
jloup@gzip.org madler@alumni.caltech.edu
|
||||||
|
|
||||||
|
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. We make all
|
||||||
|
contributions to and distributions of this project solely in our personal
|
||||||
|
capacity, and are not conveying any rights to any intellectual property of
|
||||||
|
any third parties.
|
||||||
|
|
||||||
|
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.
|
186
libraries/zlib/adler32.c
Normal file
186
libraries/zlib/adler32.c
Normal file
@ -0,0 +1,186 @@
|
|||||||
|
/* adler32.c -- compute the Adler-32 checksum of a data stream
|
||||||
|
* Copyright (C) 1995-2011, 2016 Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* @(#) $Id$ */
|
||||||
|
|
||||||
|
#include "zutil.h"
|
||||||
|
|
||||||
|
local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
|
||||||
|
|
||||||
|
#define BASE 65521U /* largest prime smaller than 65536 */
|
||||||
|
#define NMAX 5552
|
||||||
|
/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
|
||||||
|
|
||||||
|
#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;}
|
||||||
|
#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);
|
||||||
|
#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2);
|
||||||
|
#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
|
||||||
|
#define DO16(buf) DO8(buf,0); DO8(buf,8);
|
||||||
|
|
||||||
|
/* use NO_DIVIDE if your processor does not do division in hardware --
|
||||||
|
try it both ways to see which is faster */
|
||||||
|
#ifdef NO_DIVIDE
|
||||||
|
/* note that this assumes BASE is 65521, where 65536 % 65521 == 15
|
||||||
|
(thank you to John Reiser for pointing this out) */
|
||||||
|
# define CHOP(a) \
|
||||||
|
do { \
|
||||||
|
unsigned long tmp = a >> 16; \
|
||||||
|
a &= 0xffffUL; \
|
||||||
|
a += (tmp << 4) - tmp; \
|
||||||
|
} while (0)
|
||||||
|
# define MOD28(a) \
|
||||||
|
do { \
|
||||||
|
CHOP(a); \
|
||||||
|
if (a >= BASE) a -= BASE; \
|
||||||
|
} while (0)
|
||||||
|
# define MOD(a) \
|
||||||
|
do { \
|
||||||
|
CHOP(a); \
|
||||||
|
MOD28(a); \
|
||||||
|
} while (0)
|
||||||
|
# define MOD63(a) \
|
||||||
|
do { /* this assumes a is not negative */ \
|
||||||
|
z_off64_t tmp = a >> 32; \
|
||||||
|
a &= 0xffffffffL; \
|
||||||
|
a += (tmp << 8) - (tmp << 5) + tmp; \
|
||||||
|
tmp = a >> 16; \
|
||||||
|
a &= 0xffffL; \
|
||||||
|
a += (tmp << 4) - tmp; \
|
||||||
|
tmp = a >> 16; \
|
||||||
|
a &= 0xffffL; \
|
||||||
|
a += (tmp << 4) - tmp; \
|
||||||
|
if (a >= BASE) a -= BASE; \
|
||||||
|
} while (0)
|
||||||
|
#else
|
||||||
|
# define MOD(a) a %= BASE
|
||||||
|
# define MOD28(a) a %= BASE
|
||||||
|
# define MOD63(a) a %= BASE
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* ========================================================================= */
|
||||||
|
uLong ZEXPORT adler32_z(adler, buf, len)
|
||||||
|
uLong adler;
|
||||||
|
const Bytef *buf;
|
||||||
|
z_size_t len;
|
||||||
|
{
|
||||||
|
unsigned long sum2;
|
||||||
|
unsigned n;
|
||||||
|
|
||||||
|
/* split Adler-32 into component sums */
|
||||||
|
sum2 = (adler >> 16) & 0xffff;
|
||||||
|
adler &= 0xffff;
|
||||||
|
|
||||||
|
/* in case user likes doing a byte at a time, keep it fast */
|
||||||
|
if (len == 1) {
|
||||||
|
adler += buf[0];
|
||||||
|
if (adler >= BASE)
|
||||||
|
adler -= BASE;
|
||||||
|
sum2 += adler;
|
||||||
|
if (sum2 >= BASE)
|
||||||
|
sum2 -= BASE;
|
||||||
|
return adler | (sum2 << 16);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* initial Adler-32 value (deferred check for len == 1 speed) */
|
||||||
|
if (buf == Z_NULL)
|
||||||
|
return 1L;
|
||||||
|
|
||||||
|
/* in case short lengths are provided, keep it somewhat fast */
|
||||||
|
if (len < 16) {
|
||||||
|
while (len--) {
|
||||||
|
adler += *buf++;
|
||||||
|
sum2 += adler;
|
||||||
|
}
|
||||||
|
if (adler >= BASE)
|
||||||
|
adler -= BASE;
|
||||||
|
MOD28(sum2); /* only added so many BASE's */
|
||||||
|
return adler | (sum2 << 16);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* do length NMAX blocks -- requires just one modulo operation */
|
||||||
|
while (len >= NMAX) {
|
||||||
|
len -= NMAX;
|
||||||
|
n = NMAX / 16; /* NMAX is divisible by 16 */
|
||||||
|
do {
|
||||||
|
DO16(buf); /* 16 sums unrolled */
|
||||||
|
buf += 16;
|
||||||
|
} while (--n);
|
||||||
|
MOD(adler);
|
||||||
|
MOD(sum2);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* do remaining bytes (less than NMAX, still just one modulo) */
|
||||||
|
if (len) { /* avoid modulos if none remaining */
|
||||||
|
while (len >= 16) {
|
||||||
|
len -= 16;
|
||||||
|
DO16(buf);
|
||||||
|
buf += 16;
|
||||||
|
}
|
||||||
|
while (len--) {
|
||||||
|
adler += *buf++;
|
||||||
|
sum2 += adler;
|
||||||
|
}
|
||||||
|
MOD(adler);
|
||||||
|
MOD(sum2);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* return recombined sums */
|
||||||
|
return adler | (sum2 << 16);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* ========================================================================= */
|
||||||
|
uLong ZEXPORT adler32(adler, buf, len)
|
||||||
|
uLong adler;
|
||||||
|
const Bytef *buf;
|
||||||
|
uInt len;
|
||||||
|
{
|
||||||
|
return adler32_z(adler, buf, len);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* ========================================================================= */
|
||||||
|
local uLong adler32_combine_(adler1, adler2, len2)
|
||||||
|
uLong adler1;
|
||||||
|
uLong adler2;
|
||||||
|
z_off64_t len2;
|
||||||
|
{
|
||||||
|
unsigned long sum1;
|
||||||
|
unsigned long sum2;
|
||||||
|
unsigned rem;
|
||||||
|
|
||||||
|
/* for negative len, return invalid adler32 as a clue for debugging */
|
||||||
|
if (len2 < 0)
|
||||||
|
return 0xffffffffUL;
|
||||||
|
|
||||||
|
/* the derivation of this formula is left as an exercise for the reader */
|
||||||
|
MOD63(len2); /* assumes len2 >= 0 */
|
||||||
|
rem = (unsigned)len2;
|
||||||
|
sum1 = adler1 & 0xffff;
|
||||||
|
sum2 = rem * sum1;
|
||||||
|
MOD(sum2);
|
||||||
|
sum1 += (adler2 & 0xffff) + BASE - 1;
|
||||||
|
sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
|
||||||
|
if (sum1 >= BASE) sum1 -= BASE;
|
||||||
|
if (sum1 >= BASE) sum1 -= BASE;
|
||||||
|
if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
|
||||||
|
if (sum2 >= BASE) sum2 -= BASE;
|
||||||
|
return sum1 | (sum2 << 16);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* ========================================================================= */
|
||||||
|
uLong ZEXPORT adler32_combine(adler1, adler2, len2)
|
||||||
|
uLong adler1;
|
||||||
|
uLong adler2;
|
||||||
|
z_off_t len2;
|
||||||
|
{
|
||||||
|
return adler32_combine_(adler1, adler2, len2);
|
||||||
|
}
|
||||||
|
|
||||||
|
uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
|
||||||
|
uLong adler1;
|
||||||
|
uLong adler2;
|
||||||
|
z_off64_t len2;
|
||||||
|
{
|
||||||
|
return adler32_combine_(adler1, adler2, len2);
|
||||||
|
}
|
86
libraries/zlib/compress.c
Normal file
86
libraries/zlib/compress.c
Normal file
@ -0,0 +1,86 @@
|
|||||||
|
/* compress.c -- compress a memory buffer
|
||||||
|
* Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* @(#) $Id$ */
|
||||||
|
|
||||||
|
#define ZLIB_INTERNAL
|
||||||
|
#include "zlib.h"
|
||||||
|
|
||||||
|
/* ===========================================================================
|
||||||
|
Compresses the source buffer into the destination buffer. The level
|
||||||
|
parameter has the same meaning as in deflateInit. sourceLen is the byte
|
||||||
|
length of the source buffer. Upon entry, destLen is the total size of the
|
||||||
|
destination buffer, which must be at least 0.1% larger than sourceLen plus
|
||||||
|
12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
|
||||||
|
|
||||||
|
compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||||
|
memory, Z_BUF_ERROR if there was not enough room in the output buffer,
|
||||||
|
Z_STREAM_ERROR if the level parameter is invalid.
|
||||||
|
*/
|
||||||
|
int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
|
||||||
|
Bytef *dest;
|
||||||
|
uLongf *destLen;
|
||||||
|
const Bytef *source;
|
||||||
|
uLong sourceLen;
|
||||||
|
int level;
|
||||||
|
{
|
||||||
|
z_stream stream;
|
||||||
|
int err;
|
||||||
|
const uInt max = (uInt)-1;
|
||||||
|
uLong left;
|
||||||
|
|
||||||
|
left = *destLen;
|
||||||
|
*destLen = 0;
|
||||||
|
|
||||||
|
stream.zalloc = (alloc_func)0;
|
||||||
|
stream.zfree = (free_func)0;
|
||||||
|
stream.opaque = (voidpf)0;
|
||||||
|
|
||||||
|
err = deflateInit(&stream, level);
|
||||||
|
if (err != Z_OK) return err;
|
||||||
|
|
||||||
|
stream.next_out = dest;
|
||||||
|
stream.avail_out = 0;
|
||||||
|
stream.next_in = (z_const Bytef *)source;
|
||||||
|
stream.avail_in = 0;
|
||||||
|
|
||||||
|
do {
|
||||||
|
if (stream.avail_out == 0) {
|
||||||
|
stream.avail_out = left > (uLong)max ? max : (uInt)left;
|
||||||
|
left -= stream.avail_out;
|
||||||
|
}
|
||||||
|
if (stream.avail_in == 0) {
|
||||||
|
stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;
|
||||||
|
sourceLen -= stream.avail_in;
|
||||||
|
}
|
||||||
|
err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
|
||||||
|
} while (err == Z_OK);
|
||||||
|
|
||||||
|
*destLen = stream.total_out;
|
||||||
|
deflateEnd(&stream);
|
||||||
|
return err == Z_STREAM_END ? Z_OK : err;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* ===========================================================================
|
||||||
|
*/
|
||||||
|
int ZEXPORT compress (dest, destLen, source, sourceLen)
|
||||||
|
Bytef *dest;
|
||||||
|
uLongf *destLen;
|
||||||
|
const Bytef *source;
|
||||||
|
uLong sourceLen;
|
||||||
|
{
|
||||||
|
return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* ===========================================================================
|
||||||
|
If the default memLevel or windowBits for deflateInit() is changed, then
|
||||||
|
this function needs to be updated.
|
||||||
|
*/
|
||||||
|
uLong ZEXPORT compressBound (sourceLen)
|
||||||
|
uLong sourceLen;
|
||||||
|
{
|
||||||
|
return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
|
||||||
|
(sourceLen >> 25) + 13;
|
||||||
|
}
|
1116
libraries/zlib/crc32.c
Normal file
1116
libraries/zlib/crc32.c
Normal file
File diff suppressed because it is too large
Load Diff
9446
libraries/zlib/crc32.h
Normal file
9446
libraries/zlib/crc32.h
Normal file
File diff suppressed because it is too large
Load Diff
2211
libraries/zlib/deflate.c
Normal file
2211
libraries/zlib/deflate.c
Normal file
File diff suppressed because it is too large
Load Diff
346
libraries/zlib/deflate.h
Normal file
346
libraries/zlib/deflate.h
Normal file
@ -0,0 +1,346 @@
|
|||||||
|
/* deflate.h -- internal compression state
|
||||||
|
* Copyright (C) 1995-2018 Jean-loup Gailly
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* WARNING: this file should *not* be used by applications. It is
|
||||||
|
part of the implementation of the compression library and is
|
||||||
|
subject to change. Applications should only use zlib.h.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* @(#) $Id$ */
|
||||||
|
|
||||||
|
#ifndef DEFLATE_H
|
||||||
|
#define DEFLATE_H
|
||||||
|
|
||||||
|
#include "zutil.h"
|
||||||
|
|
||||||
|
/* define NO_GZIP when compiling if you want to disable gzip header and
|
||||||
|
trailer creation by deflate(). NO_GZIP would be used to avoid linking in
|
||||||
|
the crc code when it is not needed. For shared libraries, gzip encoding
|
||||||
|
should be left enabled. */
|
||||||
|
#ifndef NO_GZIP
|
||||||
|
# define GZIP
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* ===========================================================================
|
||||||
|
* Internal compression state.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define LENGTH_CODES 29
|
||||||
|
/* number of length codes, not counting the special END_BLOCK code */
|
||||||
|
|
||||||
|
#define LITERALS 256
|
||||||
|
/* number of literal bytes 0..255 */
|
||||||
|
|
||||||
|
#define L_CODES (LITERALS+1+LENGTH_CODES)
|
||||||
|
/* number of Literal or Length codes, including the END_BLOCK code */
|
||||||
|
|
||||||
|
#define D_CODES 30
|
||||||
|
/* number of distance codes */
|
||||||
|
|
||||||
|
#define BL_CODES 19
|
||||||
|
/* number of codes used to transfer the bit lengths */
|
||||||
|
|
||||||
|
#define HEAP_SIZE (2*L_CODES+1)
|
||||||
|
/* maximum heap size */
|
||||||
|
|
||||||
|
#define MAX_BITS 15
|
||||||
|
/* All codes must not exceed MAX_BITS bits */
|
||||||
|
|
||||||
|
#define Buf_size 16
|
||||||
|
/* size of bit buffer in bi_buf */
|
||||||
|
|
||||||
|
#define INIT_STATE 42 /* zlib header -> BUSY_STATE */
|
||||||
|
#ifdef GZIP
|
||||||
|
# define GZIP_STATE 57 /* gzip header -> BUSY_STATE | EXTRA_STATE */
|
||||||
|
#endif
|
||||||
|
#define EXTRA_STATE 69 /* gzip extra block -> NAME_STATE */
|
||||||
|
#define NAME_STATE 73 /* gzip file name -> COMMENT_STATE */
|
||||||
|
#define COMMENT_STATE 91 /* gzip comment -> HCRC_STATE */
|
||||||
|
#define HCRC_STATE 103 /* gzip header CRC -> BUSY_STATE */
|
||||||
|
#define BUSY_STATE 113 /* deflate -> FINISH_STATE */
|
||||||
|
#define FINISH_STATE 666 /* stream complete */
|
||||||
|
/* Stream status */
|
||||||
|
|
||||||
|
|
||||||
|
/* Data structure describing a single value and its code string. */
|
||||||
|
typedef struct ct_data_s {
|
||||||
|
union {
|
||||||
|
ush freq; /* frequency count */
|
||||||
|
ush code; /* bit string */
|
||||||
|
} fc;
|
||||||
|
union {
|
||||||
|
ush dad; /* father node in Huffman tree */
|
||||||
|
ush len; /* length of bit string */
|
||||||
|
} dl;
|
||||||
|
} FAR ct_data;
|
||||||
|
|
||||||
|
#define Freq fc.freq
|
||||||
|
#define Code fc.code
|
||||||
|
#define Dad dl.dad
|
||||||
|
#define Len dl.len
|
||||||
|
|
||||||
|
typedef struct static_tree_desc_s static_tree_desc;
|
||||||
|
|
||||||
|
typedef struct tree_desc_s {
|
||||||
|
ct_data *dyn_tree; /* the dynamic tree */
|
||||||
|
int max_code; /* largest code with non zero frequency */
|
||||||
|
const static_tree_desc *stat_desc; /* the corresponding static tree */
|
||||||
|
} FAR tree_desc;
|
||||||
|
|
||||||
|
typedef ush Pos;
|
||||||
|
typedef Pos FAR Posf;
|
||||||
|
typedef unsigned IPos;
|
||||||
|
|
||||||
|
/* A Pos is an index in the character window. We use short instead of int to
|
||||||
|
* save space in the various tables. IPos is used only for parameter passing.
|
||||||
|
*/
|
||||||
|
|
||||||
|
typedef struct internal_state {
|
||||||
|
z_streamp strm; /* pointer back to this zlib stream */
|
||||||
|
int status; /* as the name implies */
|
||||||
|
Bytef *pending_buf; /* output still pending */
|
||||||
|
ulg pending_buf_size; /* size of pending_buf */
|
||||||
|
Bytef *pending_out; /* next pending byte to output to the stream */
|
||||||
|
ulg pending; /* nb of bytes in the pending buffer */
|
||||||
|
int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
|
||||||
|
gz_headerp gzhead; /* gzip header information to write */
|
||||||
|
ulg gzindex; /* where in extra, name, or comment */
|
||||||
|
Byte method; /* can only be DEFLATED */
|
||||||
|
int last_flush; /* value of flush param for previous deflate call */
|
||||||
|
|
||||||
|
/* used by deflate.c: */
|
||||||
|
|
||||||
|
uInt w_size; /* LZ77 window size (32K by default) */
|
||||||
|
uInt w_bits; /* log2(w_size) (8..16) */
|
||||||
|
uInt w_mask; /* w_size - 1 */
|
||||||
|
|
||||||
|
Bytef *window;
|
||||||
|
/* Sliding window. Input bytes are read into the second half of the window,
|
||||||
|
* and move to the first half later to keep a dictionary of at least wSize
|
||||||
|
* bytes. With this organization, matches are limited to a distance of
|
||||||
|
* wSize-MAX_MATCH bytes, but this ensures that IO is always
|
||||||
|
* performed with a length multiple of the block size. Also, it limits
|
||||||
|
* the window size to 64K, which is quite useful on MSDOS.
|
||||||
|
* To do: use the user input buffer as sliding window.
|
||||||
|
*/
|
||||||
|
|
||||||
|
ulg window_size;
|
||||||
|
/* Actual size of window: 2*wSize, except when the user input buffer
|
||||||
|
* is directly used as sliding window.
|
||||||
|
*/
|
||||||
|
|
||||||
|
Posf *prev;
|
||||||
|
/* Link to older string with same hash index. To limit the size of this
|
||||||
|
* array to 64K, this link is maintained only for the last 32K strings.
|
||||||
|
* An index in this array is thus a window index modulo 32K.
|
||||||
|
*/
|
||||||
|
|
||||||
|
Posf *head; /* Heads of the hash chains or NIL. */
|
||||||
|
|
||||||
|
uInt ins_h; /* hash index of string to be inserted */
|
||||||
|
uInt hash_size; /* number of elements in hash table */
|
||||||
|
uInt hash_bits; /* log2(hash_size) */
|
||||||
|
uInt hash_mask; /* hash_size-1 */
|
||||||
|
|
||||||
|
uInt hash_shift;
|
||||||
|
/* Number of bits by which ins_h must be shifted at each input
|
||||||
|
* step. It must be such that after MIN_MATCH steps, the oldest
|
||||||
|
* byte no longer takes part in the hash key, that is:
|
||||||
|
* hash_shift * MIN_MATCH >= hash_bits
|
||||||
|
*/
|
||||||
|
|
||||||
|
long block_start;
|
||||||
|
/* Window position at the beginning of the current output block. Gets
|
||||||
|
* negative when the window is moved backwards.
|
||||||
|
*/
|
||||||
|
|
||||||
|
uInt match_length; /* length of best match */
|
||||||
|
IPos prev_match; /* previous match */
|
||||||
|
int match_available; /* set if previous match exists */
|
||||||
|
uInt strstart; /* start of string to insert */
|
||||||
|
uInt match_start; /* start of matching string */
|
||||||
|
uInt lookahead; /* number of valid bytes ahead in window */
|
||||||
|
|
||||||
|
uInt prev_length;
|
||||||
|
/* Length of the best match at previous step. Matches not greater than this
|
||||||
|
* are discarded. This is used in the lazy match evaluation.
|
||||||
|
*/
|
||||||
|
|
||||||
|
uInt max_chain_length;
|
||||||
|
/* To speed up deflation, hash chains are never searched beyond this
|
||||||
|
* length. A higher limit improves compression ratio but degrades the
|
||||||
|
* speed.
|
||||||
|
*/
|
||||||
|
|
||||||
|
uInt max_lazy_match;
|
||||||
|
/* Attempt to find a better match only when the current match is strictly
|
||||||
|
* smaller than this value. This mechanism is used only for compression
|
||||||
|
* levels >= 4.
|
||||||
|
*/
|
||||||
|
# define max_insert_length max_lazy_match
|
||||||
|
/* Insert new strings in the hash table only if the match length is not
|
||||||
|
* greater than this length. This saves time but degrades compression.
|
||||||
|
* max_insert_length is used only for compression levels <= 3.
|
||||||
|
*/
|
||||||
|
|
||||||
|
int level; /* compression level (1..9) */
|
||||||
|
int strategy; /* favor or force Huffman coding*/
|
||||||
|
|
||||||
|
uInt good_match;
|
||||||
|
/* Use a faster search when the previous match is longer than this */
|
||||||
|
|
||||||
|
int nice_match; /* Stop searching when current match exceeds this */
|
||||||
|
|
||||||
|
/* used by trees.c: */
|
||||||
|
/* Didn't use ct_data typedef below to suppress compiler warning */
|
||||||
|
struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */
|
||||||
|
struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
|
||||||
|
struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */
|
||||||
|
|
||||||
|
struct tree_desc_s l_desc; /* desc. for literal tree */
|
||||||
|
struct tree_desc_s d_desc; /* desc. for distance tree */
|
||||||
|
struct tree_desc_s bl_desc; /* desc. for bit length tree */
|
||||||
|
|
||||||
|
ush bl_count[MAX_BITS+1];
|
||||||
|
/* number of codes at each bit length for an optimal tree */
|
||||||
|
|
||||||
|
int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */
|
||||||
|
int heap_len; /* number of elements in the heap */
|
||||||
|
int heap_max; /* element of largest frequency */
|
||||||
|
/* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
|
||||||
|
* The same heap array is used to build all trees.
|
||||||
|
*/
|
||||||
|
|
||||||
|
uch depth[2*L_CODES+1];
|
||||||
|
/* Depth of each subtree used as tie breaker for trees of equal frequency
|
||||||
|
*/
|
||||||
|
|
||||||
|
uchf *sym_buf; /* buffer for distances and literals/lengths */
|
||||||
|
|
||||||
|
uInt lit_bufsize;
|
||||||
|
/* Size of match buffer for literals/lengths. There are 4 reasons for
|
||||||
|
* limiting lit_bufsize to 64K:
|
||||||
|
* - frequencies can be kept in 16 bit counters
|
||||||
|
* - if compression is not successful for the first block, all input
|
||||||
|
* data is still in the window so we can still emit a stored block even
|
||||||
|
* when input comes from standard input. (This can also be done for
|
||||||
|
* all blocks if lit_bufsize is not greater than 32K.)
|
||||||
|
* - if compression is not successful for a file smaller than 64K, we can
|
||||||
|
* even emit a stored file instead of a stored block (saving 5 bytes).
|
||||||
|
* This is applicable only for zip (not gzip or zlib).
|
||||||
|
* - creating new Huffman trees less frequently may not provide fast
|
||||||
|
* adaptation to changes in the input data statistics. (Take for
|
||||||
|
* example a binary file with poorly compressible code followed by
|
||||||
|
* a highly compressible string table.) Smaller buffer sizes give
|
||||||
|
* fast adaptation but have of course the overhead of transmitting
|
||||||
|
* trees more frequently.
|
||||||
|
* - I can't count above 4
|
||||||
|
*/
|
||||||
|
|
||||||
|
uInt sym_next; /* running index in sym_buf */
|
||||||
|
uInt sym_end; /* symbol table full when sym_next reaches this */
|
||||||
|
|
||||||
|
ulg opt_len; /* bit length of current block with optimal trees */
|
||||||
|
ulg static_len; /* bit length of current block with static trees */
|
||||||
|
uInt matches; /* number of string matches in current block */
|
||||||
|
uInt insert; /* bytes at end of window left to insert */
|
||||||
|
|
||||||
|
#ifdef ZLIB_DEBUG
|
||||||
|
ulg compressed_len; /* total bit length of compressed file mod 2^32 */
|
||||||
|
ulg bits_sent; /* bit length of compressed data sent mod 2^32 */
|
||||||
|
#endif
|
||||||
|
|
||||||
|
ush bi_buf;
|
||||||
|
/* Output buffer. bits are inserted starting at the bottom (least
|
||||||
|
* significant bits).
|
||||||
|
*/
|
||||||
|
int bi_valid;
|
||||||
|
/* Number of valid bits in bi_buf. All bits above the last valid bit
|
||||||
|
* are always zero.
|
||||||
|
*/
|
||||||
|
|
||||||
|
ulg high_water;
|
||||||
|
/* High water mark offset in window for initialized bytes -- bytes above
|
||||||
|
* this are set to zero in order to avoid memory check warnings when
|
||||||
|
* longest match routines access bytes past the input. This is then
|
||||||
|
* updated to the new high water mark.
|
||||||
|
*/
|
||||||
|
|
||||||
|
} FAR deflate_state;
|
||||||
|
|
||||||
|
/* Output a byte on the stream.
|
||||||
|
* IN assertion: there is enough room in pending_buf.
|
||||||
|
*/
|
||||||
|
#define put_byte(s, c) {s->pending_buf[s->pending++] = (Bytef)(c);}
|
||||||
|
|
||||||
|
|
||||||
|
#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
|
||||||
|
/* Minimum amount of lookahead, except at the end of the input file.
|
||||||
|
* See deflate.c for comments about the MIN_MATCH+1.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD)
|
||||||
|
/* In order to simplify the code, particularly on 16 bit machines, match
|
||||||
|
* distances are limited to MAX_DIST instead of WSIZE.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define WIN_INIT MAX_MATCH
|
||||||
|
/* Number of bytes after end of data in window to initialize in order to avoid
|
||||||
|
memory checker errors from longest match routines */
|
||||||
|
|
||||||
|
/* in trees.c */
|
||||||
|
void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
|
||||||
|
int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
|
||||||
|
void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
|
||||||
|
ulg stored_len, int last));
|
||||||
|
void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
|
||||||
|
void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
|
||||||
|
void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
|
||||||
|
ulg stored_len, int last));
|
||||||
|
|
||||||
|
#define d_code(dist) \
|
||||||
|
((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
|
||||||
|
/* Mapping from a distance to a distance code. dist is the distance - 1 and
|
||||||
|
* must not have side effects. _dist_code[256] and _dist_code[257] are never
|
||||||
|
* used.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef ZLIB_DEBUG
|
||||||
|
/* Inline versions of _tr_tally for speed: */
|
||||||
|
|
||||||
|
#if defined(GEN_TREES_H) || !defined(STDC)
|
||||||
|
extern uch ZLIB_INTERNAL _length_code[];
|
||||||
|
extern uch ZLIB_INTERNAL _dist_code[];
|
||||||
|
#else
|
||||||
|
extern const uch ZLIB_INTERNAL _length_code[];
|
||||||
|
extern const uch ZLIB_INTERNAL _dist_code[];
|
||||||
|
#endif
|
||||||
|
|
||||||
|
# define _tr_tally_lit(s, c, flush) \
|
||||||
|
{ uch cc = (c); \
|
||||||
|
s->sym_buf[s->sym_next++] = 0; \
|
||||||
|
s->sym_buf[s->sym_next++] = 0; \
|
||||||
|
s->sym_buf[s->sym_next++] = cc; \
|
||||||
|
s->dyn_ltree[cc].Freq++; \
|
||||||
|
flush = (s->sym_next == s->sym_end); \
|
||||||
|
}
|
||||||
|
# define _tr_tally_dist(s, distance, length, flush) \
|
||||||
|
{ uch len = (uch)(length); \
|
||||||
|
ush dist = (ush)(distance); \
|
||||||
|
s->sym_buf[s->sym_next++] = dist; \
|
||||||
|
s->sym_buf[s->sym_next++] = dist >> 8; \
|
||||||
|
s->sym_buf[s->sym_next++] = len; \
|
||||||
|
dist--; \
|
||||||
|
s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
|
||||||
|
s->dyn_dtree[d_code(dist)].Freq++; \
|
||||||
|
flush = (s->sym_next == s->sym_end); \
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
|
||||||
|
# define _tr_tally_dist(s, distance, length, flush) \
|
||||||
|
flush = _tr_tally(s, distance, length)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#endif /* DEFLATE_H */
|
25
libraries/zlib/gzclose.c
Normal file
25
libraries/zlib/gzclose.c
Normal file
@ -0,0 +1,25 @@
|
|||||||
|
/* gzclose.c -- zlib gzclose() function
|
||||||
|
* Copyright (C) 2004, 2010 Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "gzguts.h"
|
||||||
|
|
||||||
|
/* gzclose() is in a separate file so that it is linked in only if it is used.
|
||||||
|
That way the other gzclose functions can be used instead to avoid linking in
|
||||||
|
unneeded compression or decompression routines. */
|
||||||
|
int ZEXPORT gzclose(file)
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
#ifndef NO_GZCOMPRESS
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
if (file == NULL)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file);
|
||||||
|
#else
|
||||||
|
return gzclose_r(file);
|
||||||
|
#endif
|
||||||
|
}
|
219
libraries/zlib/gzguts.h
Normal file
219
libraries/zlib/gzguts.h
Normal file
@ -0,0 +1,219 @@
|
|||||||
|
/* gzguts.h -- zlib internal header definitions for gz* operations
|
||||||
|
* Copyright (C) 2004-2019 Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifdef _LARGEFILE64_SOURCE
|
||||||
|
# ifndef _LARGEFILE_SOURCE
|
||||||
|
# define _LARGEFILE_SOURCE 1
|
||||||
|
# endif
|
||||||
|
# ifdef _FILE_OFFSET_BITS
|
||||||
|
# undef _FILE_OFFSET_BITS
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef HAVE_HIDDEN
|
||||||
|
# define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
|
||||||
|
#else
|
||||||
|
# define ZLIB_INTERNAL
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#include <stdio.h>
|
||||||
|
#include "zlib.h"
|
||||||
|
#ifdef STDC
|
||||||
|
# include <string.h>
|
||||||
|
# include <stdlib.h>
|
||||||
|
# include <limits.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef _POSIX_SOURCE
|
||||||
|
# define _POSIX_SOURCE
|
||||||
|
#endif
|
||||||
|
#include <fcntl.h>
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
# include <stddef.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32)
|
||||||
|
# include <io.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(_WIN32)
|
||||||
|
# define WIDECHAR
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef WINAPI_FAMILY
|
||||||
|
# define open _open
|
||||||
|
# define read _read
|
||||||
|
# define write _write
|
||||||
|
# define close _close
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef NO_DEFLATE /* for compatibility with old definition */
|
||||||
|
# define NO_GZCOMPRESS
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
|
||||||
|
# ifndef HAVE_VSNPRINTF
|
||||||
|
# define HAVE_VSNPRINTF
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(__CYGWIN__)
|
||||||
|
# ifndef HAVE_VSNPRINTF
|
||||||
|
# define HAVE_VSNPRINTF
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410)
|
||||||
|
# ifndef HAVE_VSNPRINTF
|
||||||
|
# define HAVE_VSNPRINTF
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef HAVE_VSNPRINTF
|
||||||
|
# ifdef MSDOS
|
||||||
|
/* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
|
||||||
|
but for now we just assume it doesn't. */
|
||||||
|
# define NO_vsnprintf
|
||||||
|
# endif
|
||||||
|
# ifdef __TURBOC__
|
||||||
|
# define NO_vsnprintf
|
||||||
|
# endif
|
||||||
|
# ifdef WIN32
|
||||||
|
/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
|
||||||
|
# if !defined(vsnprintf) && !defined(NO_vsnprintf)
|
||||||
|
# if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 )
|
||||||
|
# define vsnprintf _vsnprintf
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
# ifdef __SASC
|
||||||
|
# define NO_vsnprintf
|
||||||
|
# endif
|
||||||
|
# ifdef VMS
|
||||||
|
# define NO_vsnprintf
|
||||||
|
# endif
|
||||||
|
# ifdef __OS400__
|
||||||
|
# define NO_vsnprintf
|
||||||
|
# endif
|
||||||
|
# ifdef __MVS__
|
||||||
|
# define NO_vsnprintf
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* unlike snprintf (which is required in C99), _snprintf does not guarantee
|
||||||
|
null termination of the result -- however this is only used in gzlib.c where
|
||||||
|
the result is assured to fit in the space provided */
|
||||||
|
#if defined(_MSC_VER) && _MSC_VER < 1900
|
||||||
|
# define snprintf _snprintf
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef local
|
||||||
|
# define local static
|
||||||
|
#endif
|
||||||
|
/* since "static" is used to mean two completely different things in C, we
|
||||||
|
define "local" for the non-static meaning of "static", for readability
|
||||||
|
(compile with -Dlocal if your debugger can't find static symbols) */
|
||||||
|
|
||||||
|
/* gz* functions always use library allocation functions */
|
||||||
|
#ifndef STDC
|
||||||
|
extern voidp malloc OF((uInt size));
|
||||||
|
extern void free OF((voidpf ptr));
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* get errno and strerror definition */
|
||||||
|
#if defined UNDER_CE
|
||||||
|
# include <windows.h>
|
||||||
|
# define zstrerror() gz_strwinerror((DWORD)GetLastError())
|
||||||
|
#else
|
||||||
|
# ifndef NO_STRERROR
|
||||||
|
# include <errno.h>
|
||||||
|
# define zstrerror() strerror(errno)
|
||||||
|
# else
|
||||||
|
# define zstrerror() "stdio error (consult errno)"
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* provide prototypes for these when building zlib without LFS */
|
||||||
|
#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0
|
||||||
|
ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
|
||||||
|
ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
|
||||||
|
ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
|
||||||
|
ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* default memLevel */
|
||||||
|
#if MAX_MEM_LEVEL >= 8
|
||||||
|
# define DEF_MEM_LEVEL 8
|
||||||
|
#else
|
||||||
|
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* default i/o buffer size -- double this for output when reading (this and
|
||||||
|
twice this must be able to fit in an unsigned type) */
|
||||||
|
#define GZBUFSIZE 8192
|
||||||
|
|
||||||
|
/* gzip modes, also provide a little integrity check on the passed structure */
|
||||||
|
#define GZ_NONE 0
|
||||||
|
#define GZ_READ 7247
|
||||||
|
#define GZ_WRITE 31153
|
||||||
|
#define GZ_APPEND 1 /* mode set to GZ_WRITE after the file is opened */
|
||||||
|
|
||||||
|
/* values for gz_state how */
|
||||||
|
#define LOOK 0 /* look for a gzip header */
|
||||||
|
#define COPY 1 /* copy input directly */
|
||||||
|
#define GZIP 2 /* decompress a gzip stream */
|
||||||
|
|
||||||
|
/* internal gzip file state data structure */
|
||||||
|
typedef struct {
|
||||||
|
/* exposed contents for gzgetc() macro */
|
||||||
|
struct gzFile_s x; /* "x" for exposed */
|
||||||
|
/* x.have: number of bytes available at x.next */
|
||||||
|
/* x.next: next output data to deliver or write */
|
||||||
|
/* x.pos: current position in uncompressed data */
|
||||||
|
/* used for both reading and writing */
|
||||||
|
int mode; /* see gzip modes above */
|
||||||
|
int fd; /* file descriptor */
|
||||||
|
char *path; /* path or fd for error messages */
|
||||||
|
unsigned size; /* buffer size, zero if not allocated yet */
|
||||||
|
unsigned want; /* requested buffer size, default is GZBUFSIZE */
|
||||||
|
unsigned char *in; /* input buffer (double-sized when writing) */
|
||||||
|
unsigned char *out; /* output buffer (double-sized when reading) */
|
||||||
|
int direct; /* 0 if processing gzip, 1 if transparent */
|
||||||
|
/* just for reading */
|
||||||
|
int how; /* 0: get header, 1: copy, 2: decompress */
|
||||||
|
z_off64_t start; /* where the gzip data started, for rewinding */
|
||||||
|
int eof; /* true if end of input file reached */
|
||||||
|
int past; /* true if read requested past end */
|
||||||
|
/* just for writing */
|
||||||
|
int level; /* compression level */
|
||||||
|
int strategy; /* compression strategy */
|
||||||
|
int reset; /* true if a reset is pending after a Z_FINISH */
|
||||||
|
/* seek request */
|
||||||
|
z_off64_t skip; /* amount to skip (already rewound if backwards) */
|
||||||
|
int seek; /* true if seek request pending */
|
||||||
|
/* error information */
|
||||||
|
int err; /* error code */
|
||||||
|
char *msg; /* error message */
|
||||||
|
/* zlib inflate or deflate stream */
|
||||||
|
z_stream strm; /* stream structure in-place (not a pointer) */
|
||||||
|
} gz_state;
|
||||||
|
typedef gz_state FAR *gz_statep;
|
||||||
|
|
||||||
|
/* shared functions */
|
||||||
|
void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *));
|
||||||
|
#if defined UNDER_CE
|
||||||
|
char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error));
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
|
||||||
|
value -- needed when comparing unsigned to z_off64_t, which is signed
|
||||||
|
(possible z_off64_t types off_t, off64_t, and long are all signed) */
|
||||||
|
#ifdef INT_MAX
|
||||||
|
# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX)
|
||||||
|
#else
|
||||||
|
unsigned ZLIB_INTERNAL gz_intmax OF((void));
|
||||||
|
# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax())
|
||||||
|
#endif
|
639
libraries/zlib/gzlib.c
Normal file
639
libraries/zlib/gzlib.c
Normal file
@ -0,0 +1,639 @@
|
|||||||
|
/* gzlib.c -- zlib functions common to reading and writing gzip files
|
||||||
|
* Copyright (C) 2004-2019 Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "gzguts.h"
|
||||||
|
|
||||||
|
#if defined(_WIN32) && !defined(__BORLANDC__)
|
||||||
|
# define LSEEK _lseeki64
|
||||||
|
#else
|
||||||
|
#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
|
||||||
|
# define LSEEK lseek64
|
||||||
|
#else
|
||||||
|
# define LSEEK lseek
|
||||||
|
#endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* Local functions */
|
||||||
|
local void gz_reset OF((gz_statep));
|
||||||
|
local gzFile gz_open OF((const void *, int, const char *));
|
||||||
|
|
||||||
|
#if defined UNDER_CE
|
||||||
|
|
||||||
|
/* Map the Windows error number in ERROR to a locale-dependent error message
|
||||||
|
string and return a pointer to it. Typically, the values for ERROR come
|
||||||
|
from GetLastError.
|
||||||
|
|
||||||
|
The string pointed to shall not be modified by the application, but may be
|
||||||
|
overwritten by a subsequent call to gz_strwinerror
|
||||||
|
|
||||||
|
The gz_strwinerror function does not change the current setting of
|
||||||
|
GetLastError. */
|
||||||
|
char ZLIB_INTERNAL *gz_strwinerror (error)
|
||||||
|
DWORD error;
|
||||||
|
{
|
||||||
|
static char buf[1024];
|
||||||
|
|
||||||
|
wchar_t *msgbuf;
|
||||||
|
DWORD lasterr = GetLastError();
|
||||||
|
DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
|
||||||
|
| FORMAT_MESSAGE_ALLOCATE_BUFFER,
|
||||||
|
NULL,
|
||||||
|
error,
|
||||||
|
0, /* Default language */
|
||||||
|
(LPVOID)&msgbuf,
|
||||||
|
0,
|
||||||
|
NULL);
|
||||||
|
if (chars != 0) {
|
||||||
|
/* If there is an \r\n appended, zap it. */
|
||||||
|
if (chars >= 2
|
||||||
|
&& msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {
|
||||||
|
chars -= 2;
|
||||||
|
msgbuf[chars] = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (chars > sizeof (buf) - 1) {
|
||||||
|
chars = sizeof (buf) - 1;
|
||||||
|
msgbuf[chars] = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
wcstombs(buf, msgbuf, chars + 1);
|
||||||
|
LocalFree(msgbuf);
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
sprintf(buf, "unknown win32 error (%ld)", error);
|
||||||
|
}
|
||||||
|
|
||||||
|
SetLastError(lasterr);
|
||||||
|
return buf;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif /* UNDER_CE */
|
||||||
|
|
||||||
|
/* Reset gzip file state */
|
||||||
|
local void gz_reset(state)
|
||||||
|
gz_statep state;
|
||||||
|
{
|
||||||
|
state->x.have = 0; /* no output data available */
|
||||||
|
if (state->mode == GZ_READ) { /* for reading ... */
|
||||||
|
state->eof = 0; /* not at end of file */
|
||||||
|
state->past = 0; /* have not read past end yet */
|
||||||
|
state->how = LOOK; /* look for gzip header */
|
||||||
|
}
|
||||||
|
else /* for writing ... */
|
||||||
|
state->reset = 0; /* no deflateReset pending */
|
||||||
|
state->seek = 0; /* no seek request pending */
|
||||||
|
gz_error(state, Z_OK, NULL); /* clear error */
|
||||||
|
state->x.pos = 0; /* no uncompressed data yet */
|
||||||
|
state->strm.avail_in = 0; /* no input data yet */
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Open a gzip file either by name or file descriptor. */
|
||||||
|
local gzFile gz_open(path, fd, mode)
|
||||||
|
const void *path;
|
||||||
|
int fd;
|
||||||
|
const char *mode;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
z_size_t len;
|
||||||
|
int oflag;
|
||||||
|
#ifdef O_CLOEXEC
|
||||||
|
int cloexec = 0;
|
||||||
|
#endif
|
||||||
|
#ifdef O_EXCL
|
||||||
|
int exclusive = 0;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* check input */
|
||||||
|
if (path == NULL)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
/* allocate gzFile structure to return */
|
||||||
|
state = (gz_statep)malloc(sizeof(gz_state));
|
||||||
|
if (state == NULL)
|
||||||
|
return NULL;
|
||||||
|
state->size = 0; /* no buffers allocated yet */
|
||||||
|
state->want = GZBUFSIZE; /* requested buffer size */
|
||||||
|
state->msg = NULL; /* no error message yet */
|
||||||
|
|
||||||
|
/* interpret mode */
|
||||||
|
state->mode = GZ_NONE;
|
||||||
|
state->level = Z_DEFAULT_COMPRESSION;
|
||||||
|
state->strategy = Z_DEFAULT_STRATEGY;
|
||||||
|
state->direct = 0;
|
||||||
|
while (*mode) {
|
||||||
|
if (*mode >= '0' && *mode <= '9')
|
||||||
|
state->level = *mode - '0';
|
||||||
|
else
|
||||||
|
switch (*mode) {
|
||||||
|
case 'r':
|
||||||
|
state->mode = GZ_READ;
|
||||||
|
break;
|
||||||
|
#ifndef NO_GZCOMPRESS
|
||||||
|
case 'w':
|
||||||
|
state->mode = GZ_WRITE;
|
||||||
|
break;
|
||||||
|
case 'a':
|
||||||
|
state->mode = GZ_APPEND;
|
||||||
|
break;
|
||||||
|
#endif
|
||||||
|
case '+': /* can't read and write at the same time */
|
||||||
|
free(state);
|
||||||
|
return NULL;
|
||||||
|
case 'b': /* ignore -- will request binary anyway */
|
||||||
|
break;
|
||||||
|
#ifdef O_CLOEXEC
|
||||||
|
case 'e':
|
||||||
|
cloexec = 1;
|
||||||
|
break;
|
||||||
|
#endif
|
||||||
|
#ifdef O_EXCL
|
||||||
|
case 'x':
|
||||||
|
exclusive = 1;
|
||||||
|
break;
|
||||||
|
#endif
|
||||||
|
case 'f':
|
||||||
|
state->strategy = Z_FILTERED;
|
||||||
|
break;
|
||||||
|
case 'h':
|
||||||
|
state->strategy = Z_HUFFMAN_ONLY;
|
||||||
|
break;
|
||||||
|
case 'R':
|
||||||
|
state->strategy = Z_RLE;
|
||||||
|
break;
|
||||||
|
case 'F':
|
||||||
|
state->strategy = Z_FIXED;
|
||||||
|
break;
|
||||||
|
case 'T':
|
||||||
|
state->direct = 1;
|
||||||
|
break;
|
||||||
|
default: /* could consider as an error, but just ignore */
|
||||||
|
;
|
||||||
|
}
|
||||||
|
mode++;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* must provide an "r", "w", or "a" */
|
||||||
|
if (state->mode == GZ_NONE) {
|
||||||
|
free(state);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* can't force transparent read */
|
||||||
|
if (state->mode == GZ_READ) {
|
||||||
|
if (state->direct) {
|
||||||
|
free(state);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
state->direct = 1; /* for empty file */
|
||||||
|
}
|
||||||
|
|
||||||
|
/* save the path name for error messages */
|
||||||
|
#ifdef WIDECHAR
|
||||||
|
if (fd == -2) {
|
||||||
|
len = wcstombs(NULL, path, 0);
|
||||||
|
if (len == (z_size_t)-1)
|
||||||
|
len = 0;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
#endif
|
||||||
|
len = strlen((const char *)path);
|
||||||
|
state->path = (char *)malloc(len + 1);
|
||||||
|
if (state->path == NULL) {
|
||||||
|
free(state);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
#ifdef WIDECHAR
|
||||||
|
if (fd == -2)
|
||||||
|
if (len)
|
||||||
|
wcstombs(state->path, path, len + 1);
|
||||||
|
else
|
||||||
|
*(state->path) = 0;
|
||||||
|
else
|
||||||
|
#endif
|
||||||
|
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
|
||||||
|
(void)snprintf(state->path, len + 1, "%s", (const char *)path);
|
||||||
|
#else
|
||||||
|
strcpy(state->path, path);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* compute the flags for open() */
|
||||||
|
oflag =
|
||||||
|
#ifdef O_LARGEFILE
|
||||||
|
O_LARGEFILE |
|
||||||
|
#endif
|
||||||
|
#ifdef O_BINARY
|
||||||
|
O_BINARY |
|
||||||
|
#endif
|
||||||
|
#ifdef O_CLOEXEC
|
||||||
|
(cloexec ? O_CLOEXEC : 0) |
|
||||||
|
#endif
|
||||||
|
(state->mode == GZ_READ ?
|
||||||
|
O_RDONLY :
|
||||||
|
(O_WRONLY | O_CREAT |
|
||||||
|
#ifdef O_EXCL
|
||||||
|
(exclusive ? O_EXCL : 0) |
|
||||||
|
#endif
|
||||||
|
(state->mode == GZ_WRITE ?
|
||||||
|
O_TRUNC :
|
||||||
|
O_APPEND)));
|
||||||
|
|
||||||
|
/* open the file with the appropriate flags (or just use fd) */
|
||||||
|
state->fd = fd > -1 ? fd : (
|
||||||
|
#ifdef WIDECHAR
|
||||||
|
fd == -2 ? _wopen(path, oflag, 0666) :
|
||||||
|
#endif
|
||||||
|
open((const char *)path, oflag, 0666));
|
||||||
|
if (state->fd == -1) {
|
||||||
|
free(state->path);
|
||||||
|
free(state);
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
if (state->mode == GZ_APPEND) {
|
||||||
|
LSEEK(state->fd, 0, SEEK_END); /* so gzoffset() is correct */
|
||||||
|
state->mode = GZ_WRITE; /* simplify later checks */
|
||||||
|
}
|
||||||
|
|
||||||
|
/* save the current position for rewinding (only if reading) */
|
||||||
|
if (state->mode == GZ_READ) {
|
||||||
|
state->start = LSEEK(state->fd, 0, SEEK_CUR);
|
||||||
|
if (state->start == -1) state->start = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* initialize stream */
|
||||||
|
gz_reset(state);
|
||||||
|
|
||||||
|
/* return stream */
|
||||||
|
return (gzFile)state;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
gzFile ZEXPORT gzopen(path, mode)
|
||||||
|
const char *path;
|
||||||
|
const char *mode;
|
||||||
|
{
|
||||||
|
return gz_open(path, -1, mode);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
gzFile ZEXPORT gzopen64(path, mode)
|
||||||
|
const char *path;
|
||||||
|
const char *mode;
|
||||||
|
{
|
||||||
|
return gz_open(path, -1, mode);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
gzFile ZEXPORT gzdopen(fd, mode)
|
||||||
|
int fd;
|
||||||
|
const char *mode;
|
||||||
|
{
|
||||||
|
char *path; /* identifier for error messages */
|
||||||
|
gzFile gz;
|
||||||
|
|
||||||
|
if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
|
||||||
|
return NULL;
|
||||||
|
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
|
||||||
|
(void)snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd);
|
||||||
|
#else
|
||||||
|
sprintf(path, "<fd:%d>", fd); /* for debugging */
|
||||||
|
#endif
|
||||||
|
gz = gz_open(path, fd, mode);
|
||||||
|
free(path);
|
||||||
|
return gz;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
#ifdef WIDECHAR
|
||||||
|
gzFile ZEXPORT gzopen_w(path, mode)
|
||||||
|
const wchar_t *path;
|
||||||
|
const char *mode;
|
||||||
|
{
|
||||||
|
return gz_open(path, -2, mode);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzbuffer(file, size)
|
||||||
|
gzFile file;
|
||||||
|
unsigned size;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure and check integrity */
|
||||||
|
if (file == NULL)
|
||||||
|
return -1;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
if (state->mode != GZ_READ && state->mode != GZ_WRITE)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* make sure we haven't already allocated memory */
|
||||||
|
if (state->size != 0)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* check and set requested size */
|
||||||
|
if ((size << 1) < size)
|
||||||
|
return -1; /* need to be able to double it */
|
||||||
|
if (size < 2)
|
||||||
|
size = 2; /* need two bytes to check magic header */
|
||||||
|
state->want = size;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzrewind(file)
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return -1;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're reading and that there's no error */
|
||||||
|
if (state->mode != GZ_READ ||
|
||||||
|
(state->err != Z_OK && state->err != Z_BUF_ERROR))
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* back up and start over */
|
||||||
|
if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
|
||||||
|
return -1;
|
||||||
|
gz_reset(state);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
z_off64_t ZEXPORT gzseek64(file, offset, whence)
|
||||||
|
gzFile file;
|
||||||
|
z_off64_t offset;
|
||||||
|
int whence;
|
||||||
|
{
|
||||||
|
unsigned n;
|
||||||
|
z_off64_t ret;
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure and check integrity */
|
||||||
|
if (file == NULL)
|
||||||
|
return -1;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
if (state->mode != GZ_READ && state->mode != GZ_WRITE)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* check that there's no error */
|
||||||
|
if (state->err != Z_OK && state->err != Z_BUF_ERROR)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* can only seek from start or relative to current position */
|
||||||
|
if (whence != SEEK_SET && whence != SEEK_CUR)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* normalize offset to a SEEK_CUR specification */
|
||||||
|
if (whence == SEEK_SET)
|
||||||
|
offset -= state->x.pos;
|
||||||
|
else if (state->seek)
|
||||||
|
offset += state->skip;
|
||||||
|
state->seek = 0;
|
||||||
|
|
||||||
|
/* if within raw area while reading, just go there */
|
||||||
|
if (state->mode == GZ_READ && state->how == COPY &&
|
||||||
|
state->x.pos + offset >= 0) {
|
||||||
|
ret = LSEEK(state->fd, offset - (z_off64_t)state->x.have, SEEK_CUR);
|
||||||
|
if (ret == -1)
|
||||||
|
return -1;
|
||||||
|
state->x.have = 0;
|
||||||
|
state->eof = 0;
|
||||||
|
state->past = 0;
|
||||||
|
state->seek = 0;
|
||||||
|
gz_error(state, Z_OK, NULL);
|
||||||
|
state->strm.avail_in = 0;
|
||||||
|
state->x.pos += offset;
|
||||||
|
return state->x.pos;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* calculate skip amount, rewinding if needed for back seek when reading */
|
||||||
|
if (offset < 0) {
|
||||||
|
if (state->mode != GZ_READ) /* writing -- can't go backwards */
|
||||||
|
return -1;
|
||||||
|
offset += state->x.pos;
|
||||||
|
if (offset < 0) /* before start of file! */
|
||||||
|
return -1;
|
||||||
|
if (gzrewind(file) == -1) /* rewind, then skip to offset */
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* if reading, skip what's in output buffer (one less gzgetc() check) */
|
||||||
|
if (state->mode == GZ_READ) {
|
||||||
|
n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ?
|
||||||
|
(unsigned)offset : state->x.have;
|
||||||
|
state->x.have -= n;
|
||||||
|
state->x.next += n;
|
||||||
|
state->x.pos += n;
|
||||||
|
offset -= n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* request skip (if not zero) */
|
||||||
|
if (offset) {
|
||||||
|
state->seek = 1;
|
||||||
|
state->skip = offset;
|
||||||
|
}
|
||||||
|
return state->x.pos + offset;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
z_off_t ZEXPORT gzseek(file, offset, whence)
|
||||||
|
gzFile file;
|
||||||
|
z_off_t offset;
|
||||||
|
int whence;
|
||||||
|
{
|
||||||
|
z_off64_t ret;
|
||||||
|
|
||||||
|
ret = gzseek64(file, (z_off64_t)offset, whence);
|
||||||
|
return ret == (z_off_t)ret ? (z_off_t)ret : -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
z_off64_t ZEXPORT gztell64(file)
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure and check integrity */
|
||||||
|
if (file == NULL)
|
||||||
|
return -1;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
if (state->mode != GZ_READ && state->mode != GZ_WRITE)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* return position */
|
||||||
|
return state->x.pos + (state->seek ? state->skip : 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
z_off_t ZEXPORT gztell(file)
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
z_off64_t ret;
|
||||||
|
|
||||||
|
ret = gztell64(file);
|
||||||
|
return ret == (z_off_t)ret ? (z_off_t)ret : -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
z_off64_t ZEXPORT gzoffset64(file)
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
z_off64_t offset;
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure and check integrity */
|
||||||
|
if (file == NULL)
|
||||||
|
return -1;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
if (state->mode != GZ_READ && state->mode != GZ_WRITE)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* compute and return effective offset in file */
|
||||||
|
offset = LSEEK(state->fd, 0, SEEK_CUR);
|
||||||
|
if (offset == -1)
|
||||||
|
return -1;
|
||||||
|
if (state->mode == GZ_READ) /* reading */
|
||||||
|
offset -= state->strm.avail_in; /* don't count buffered input */
|
||||||
|
return offset;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
z_off_t ZEXPORT gzoffset(file)
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
z_off64_t ret;
|
||||||
|
|
||||||
|
ret = gzoffset64(file);
|
||||||
|
return ret == (z_off_t)ret ? (z_off_t)ret : -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzeof(file)
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure and check integrity */
|
||||||
|
if (file == NULL)
|
||||||
|
return 0;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
if (state->mode != GZ_READ && state->mode != GZ_WRITE)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/* return end-of-file state */
|
||||||
|
return state->mode == GZ_READ ? state->past : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
const char * ZEXPORT gzerror(file, errnum)
|
||||||
|
gzFile file;
|
||||||
|
int *errnum;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure and check integrity */
|
||||||
|
if (file == NULL)
|
||||||
|
return NULL;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
if (state->mode != GZ_READ && state->mode != GZ_WRITE)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
/* return error information */
|
||||||
|
if (errnum != NULL)
|
||||||
|
*errnum = state->err;
|
||||||
|
return state->err == Z_MEM_ERROR ? "out of memory" :
|
||||||
|
(state->msg == NULL ? "" : state->msg);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
void ZEXPORT gzclearerr(file)
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure and check integrity */
|
||||||
|
if (file == NULL)
|
||||||
|
return;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
if (state->mode != GZ_READ && state->mode != GZ_WRITE)
|
||||||
|
return;
|
||||||
|
|
||||||
|
/* clear error and end-of-file */
|
||||||
|
if (state->mode == GZ_READ) {
|
||||||
|
state->eof = 0;
|
||||||
|
state->past = 0;
|
||||||
|
}
|
||||||
|
gz_error(state, Z_OK, NULL);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Create an error message in allocated memory and set state->err and
|
||||||
|
state->msg accordingly. Free any previous error message already there. Do
|
||||||
|
not try to free or allocate space if the error is Z_MEM_ERROR (out of
|
||||||
|
memory). Simply save the error message as a static string. If there is an
|
||||||
|
allocation failure constructing the error message, then convert the error to
|
||||||
|
out of memory. */
|
||||||
|
void ZLIB_INTERNAL gz_error(state, err, msg)
|
||||||
|
gz_statep state;
|
||||||
|
int err;
|
||||||
|
const char *msg;
|
||||||
|
{
|
||||||
|
/* free previously allocated message and clear */
|
||||||
|
if (state->msg != NULL) {
|
||||||
|
if (state->err != Z_MEM_ERROR)
|
||||||
|
free(state->msg);
|
||||||
|
state->msg = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */
|
||||||
|
if (err != Z_OK && err != Z_BUF_ERROR)
|
||||||
|
state->x.have = 0;
|
||||||
|
|
||||||
|
/* set error code, and if no message, then done */
|
||||||
|
state->err = err;
|
||||||
|
if (msg == NULL)
|
||||||
|
return;
|
||||||
|
|
||||||
|
/* for an out of memory error, return literal string when requested */
|
||||||
|
if (err == Z_MEM_ERROR)
|
||||||
|
return;
|
||||||
|
|
||||||
|
/* construct error message with path */
|
||||||
|
if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) ==
|
||||||
|
NULL) {
|
||||||
|
state->err = Z_MEM_ERROR;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
|
||||||
|
(void)snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
|
||||||
|
"%s%s%s", state->path, ": ", msg);
|
||||||
|
#else
|
||||||
|
strcpy(state->msg, state->path);
|
||||||
|
strcat(state->msg, ": ");
|
||||||
|
strcat(state->msg, msg);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifndef INT_MAX
|
||||||
|
/* portably return maximum value for an int (when limits.h presumed not
|
||||||
|
available) -- we need to do this to cover cases where 2's complement not
|
||||||
|
used, since C standard permits 1's complement and sign-bit representations,
|
||||||
|
otherwise we could just use ((unsigned)-1) >> 1 */
|
||||||
|
unsigned ZLIB_INTERNAL gz_intmax()
|
||||||
|
{
|
||||||
|
unsigned p, q;
|
||||||
|
|
||||||
|
p = 1;
|
||||||
|
do {
|
||||||
|
q = p;
|
||||||
|
p <<= 1;
|
||||||
|
p++;
|
||||||
|
} while (p > q);
|
||||||
|
return q >> 1;
|
||||||
|
}
|
||||||
|
#endif
|
652
libraries/zlib/gzread.c
Normal file
652
libraries/zlib/gzread.c
Normal file
@ -0,0 +1,652 @@
|
|||||||
|
/* gzread.c -- zlib functions for reading gzip files
|
||||||
|
* Copyright (C) 2004-2017 Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "gzguts.h"
|
||||||
|
|
||||||
|
/* Local functions */
|
||||||
|
local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *));
|
||||||
|
local int gz_avail OF((gz_statep));
|
||||||
|
local int gz_look OF((gz_statep));
|
||||||
|
local int gz_decomp OF((gz_statep));
|
||||||
|
local int gz_fetch OF((gz_statep));
|
||||||
|
local int gz_skip OF((gz_statep, z_off64_t));
|
||||||
|
local z_size_t gz_read OF((gz_statep, voidp, z_size_t));
|
||||||
|
|
||||||
|
/* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from
|
||||||
|
state->fd, and update state->eof, state->err, and state->msg as appropriate.
|
||||||
|
This function needs to loop on read(), since read() is not guaranteed to
|
||||||
|
read the number of bytes requested, depending on the type of descriptor. */
|
||||||
|
local int gz_load(state, buf, len, have)
|
||||||
|
gz_statep state;
|
||||||
|
unsigned char *buf;
|
||||||
|
unsigned len;
|
||||||
|
unsigned *have;
|
||||||
|
{
|
||||||
|
int ret;
|
||||||
|
unsigned get, max = ((unsigned)-1 >> 2) + 1;
|
||||||
|
|
||||||
|
*have = 0;
|
||||||
|
do {
|
||||||
|
get = len - *have;
|
||||||
|
if (get > max)
|
||||||
|
get = max;
|
||||||
|
ret = read(state->fd, buf + *have, get);
|
||||||
|
if (ret <= 0)
|
||||||
|
break;
|
||||||
|
*have += (unsigned)ret;
|
||||||
|
} while (*have < len);
|
||||||
|
if (ret < 0) {
|
||||||
|
gz_error(state, Z_ERRNO, zstrerror());
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
if (ret == 0)
|
||||||
|
state->eof = 1;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Load up input buffer and set eof flag if last data loaded -- return -1 on
|
||||||
|
error, 0 otherwise. Note that the eof flag is set when the end of the input
|
||||||
|
file is reached, even though there may be unused data in the buffer. Once
|
||||||
|
that data has been used, no more attempts will be made to read the file.
|
||||||
|
If strm->avail_in != 0, then the current data is moved to the beginning of
|
||||||
|
the input buffer, and then the remainder of the buffer is loaded with the
|
||||||
|
available data from the input file. */
|
||||||
|
local int gz_avail(state)
|
||||||
|
gz_statep state;
|
||||||
|
{
|
||||||
|
unsigned got;
|
||||||
|
z_streamp strm = &(state->strm);
|
||||||
|
|
||||||
|
if (state->err != Z_OK && state->err != Z_BUF_ERROR)
|
||||||
|
return -1;
|
||||||
|
if (state->eof == 0) {
|
||||||
|
if (strm->avail_in) { /* copy what's there to the start */
|
||||||
|
unsigned char *p = state->in;
|
||||||
|
unsigned const char *q = strm->next_in;
|
||||||
|
unsigned n = strm->avail_in;
|
||||||
|
do {
|
||||||
|
*p++ = *q++;
|
||||||
|
} while (--n);
|
||||||
|
}
|
||||||
|
if (gz_load(state, state->in + strm->avail_in,
|
||||||
|
state->size - strm->avail_in, &got) == -1)
|
||||||
|
return -1;
|
||||||
|
strm->avail_in += got;
|
||||||
|
strm->next_in = state->in;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Look for gzip header, set up for inflate or copy. state->x.have must be 0.
|
||||||
|
If this is the first time in, allocate required memory. state->how will be
|
||||||
|
left unchanged if there is no more input data available, will be set to COPY
|
||||||
|
if there is no gzip header and direct copying will be performed, or it will
|
||||||
|
be set to GZIP for decompression. If direct copying, then leftover input
|
||||||
|
data from the input buffer will be copied to the output buffer. In that
|
||||||
|
case, all further file reads will be directly to either the output buffer or
|
||||||
|
a user buffer. If decompressing, the inflate state will be initialized.
|
||||||
|
gz_look() will return 0 on success or -1 on failure. */
|
||||||
|
local int gz_look(state)
|
||||||
|
gz_statep state;
|
||||||
|
{
|
||||||
|
z_streamp strm = &(state->strm);
|
||||||
|
|
||||||
|
/* allocate read buffers and inflate memory */
|
||||||
|
if (state->size == 0) {
|
||||||
|
/* allocate buffers */
|
||||||
|
state->in = (unsigned char *)malloc(state->want);
|
||||||
|
state->out = (unsigned char *)malloc(state->want << 1);
|
||||||
|
if (state->in == NULL || state->out == NULL) {
|
||||||
|
free(state->out);
|
||||||
|
free(state->in);
|
||||||
|
gz_error(state, Z_MEM_ERROR, "out of memory");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
state->size = state->want;
|
||||||
|
|
||||||
|
/* allocate inflate memory */
|
||||||
|
state->strm.zalloc = Z_NULL;
|
||||||
|
state->strm.zfree = Z_NULL;
|
||||||
|
state->strm.opaque = Z_NULL;
|
||||||
|
state->strm.avail_in = 0;
|
||||||
|
state->strm.next_in = Z_NULL;
|
||||||
|
if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) { /* gunzip */
|
||||||
|
free(state->out);
|
||||||
|
free(state->in);
|
||||||
|
state->size = 0;
|
||||||
|
gz_error(state, Z_MEM_ERROR, "out of memory");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* get at least the magic bytes in the input buffer */
|
||||||
|
if (strm->avail_in < 2) {
|
||||||
|
if (gz_avail(state) == -1)
|
||||||
|
return -1;
|
||||||
|
if (strm->avail_in == 0)
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* look for gzip magic bytes -- if there, do gzip decoding (note: there is
|
||||||
|
a logical dilemma here when considering the case of a partially written
|
||||||
|
gzip file, to wit, if a single 31 byte is written, then we cannot tell
|
||||||
|
whether this is a single-byte file, or just a partially written gzip
|
||||||
|
file -- for here we assume that if a gzip file is being written, then
|
||||||
|
the header will be written in a single operation, so that reading a
|
||||||
|
single byte is sufficient indication that it is not a gzip file) */
|
||||||
|
if (strm->avail_in > 1 &&
|
||||||
|
strm->next_in[0] == 31 && strm->next_in[1] == 139) {
|
||||||
|
inflateReset(strm);
|
||||||
|
state->how = GZIP;
|
||||||
|
state->direct = 0;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* no gzip header -- if we were decoding gzip before, then this is trailing
|
||||||
|
garbage. Ignore the trailing garbage and finish. */
|
||||||
|
if (state->direct == 0) {
|
||||||
|
strm->avail_in = 0;
|
||||||
|
state->eof = 1;
|
||||||
|
state->x.have = 0;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* doing raw i/o, copy any leftover input to output -- this assumes that
|
||||||
|
the output buffer is larger than the input buffer, which also assures
|
||||||
|
space for gzungetc() */
|
||||||
|
state->x.next = state->out;
|
||||||
|
if (strm->avail_in) {
|
||||||
|
memcpy(state->x.next, strm->next_in, strm->avail_in);
|
||||||
|
state->x.have = strm->avail_in;
|
||||||
|
strm->avail_in = 0;
|
||||||
|
}
|
||||||
|
state->how = COPY;
|
||||||
|
state->direct = 1;
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Decompress from input to the provided next_out and avail_out in the state.
|
||||||
|
On return, state->x.have and state->x.next point to the just decompressed
|
||||||
|
data. If the gzip stream completes, state->how is reset to LOOK to look for
|
||||||
|
the next gzip stream or raw data, once state->x.have is depleted. Returns 0
|
||||||
|
on success, -1 on failure. */
|
||||||
|
local int gz_decomp(state)
|
||||||
|
gz_statep state;
|
||||||
|
{
|
||||||
|
int ret = Z_OK;
|
||||||
|
unsigned had;
|
||||||
|
z_streamp strm = &(state->strm);
|
||||||
|
|
||||||
|
/* fill output buffer up to end of deflate stream */
|
||||||
|
had = strm->avail_out;
|
||||||
|
do {
|
||||||
|
/* get more input for inflate() */
|
||||||
|
if (strm->avail_in == 0 && gz_avail(state) == -1)
|
||||||
|
return -1;
|
||||||
|
if (strm->avail_in == 0) {
|
||||||
|
gz_error(state, Z_BUF_ERROR, "unexpected end of file");
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* decompress and handle errors */
|
||||||
|
ret = inflate(strm, Z_NO_FLUSH);
|
||||||
|
if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
|
||||||
|
gz_error(state, Z_STREAM_ERROR,
|
||||||
|
"internal error: inflate stream corrupt");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
if (ret == Z_MEM_ERROR) {
|
||||||
|
gz_error(state, Z_MEM_ERROR, "out of memory");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
if (ret == Z_DATA_ERROR) { /* deflate stream invalid */
|
||||||
|
gz_error(state, Z_DATA_ERROR,
|
||||||
|
strm->msg == NULL ? "compressed data error" : strm->msg);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
} while (strm->avail_out && ret != Z_STREAM_END);
|
||||||
|
|
||||||
|
/* update available output */
|
||||||
|
state->x.have = had - strm->avail_out;
|
||||||
|
state->x.next = strm->next_out - state->x.have;
|
||||||
|
|
||||||
|
/* if the gzip stream completed successfully, look for another */
|
||||||
|
if (ret == Z_STREAM_END)
|
||||||
|
state->how = LOOK;
|
||||||
|
|
||||||
|
/* good decompression */
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Fetch data and put it in the output buffer. Assumes state->x.have is 0.
|
||||||
|
Data is either copied from the input file or decompressed from the input
|
||||||
|
file depending on state->how. If state->how is LOOK, then a gzip header is
|
||||||
|
looked for to determine whether to copy or decompress. Returns -1 on error,
|
||||||
|
otherwise 0. gz_fetch() will leave state->how as COPY or GZIP unless the
|
||||||
|
end of the input file has been reached and all data has been processed. */
|
||||||
|
local int gz_fetch(state)
|
||||||
|
gz_statep state;
|
||||||
|
{
|
||||||
|
z_streamp strm = &(state->strm);
|
||||||
|
|
||||||
|
do {
|
||||||
|
switch(state->how) {
|
||||||
|
case LOOK: /* -> LOOK, COPY (only if never GZIP), or GZIP */
|
||||||
|
if (gz_look(state) == -1)
|
||||||
|
return -1;
|
||||||
|
if (state->how == LOOK)
|
||||||
|
return 0;
|
||||||
|
break;
|
||||||
|
case COPY: /* -> COPY */
|
||||||
|
if (gz_load(state, state->out, state->size << 1, &(state->x.have))
|
||||||
|
== -1)
|
||||||
|
return -1;
|
||||||
|
state->x.next = state->out;
|
||||||
|
return 0;
|
||||||
|
case GZIP: /* -> GZIP or LOOK (if end of gzip stream) */
|
||||||
|
strm->avail_out = state->size << 1;
|
||||||
|
strm->next_out = state->out;
|
||||||
|
if (gz_decomp(state) == -1)
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
} while (state->x.have == 0 && (!state->eof || strm->avail_in));
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Skip len uncompressed bytes of output. Return -1 on error, 0 on success. */
|
||||||
|
local int gz_skip(state, len)
|
||||||
|
gz_statep state;
|
||||||
|
z_off64_t len;
|
||||||
|
{
|
||||||
|
unsigned n;
|
||||||
|
|
||||||
|
/* skip over len bytes or reach end-of-file, whichever comes first */
|
||||||
|
while (len)
|
||||||
|
/* skip over whatever is in output buffer */
|
||||||
|
if (state->x.have) {
|
||||||
|
n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?
|
||||||
|
(unsigned)len : state->x.have;
|
||||||
|
state->x.have -= n;
|
||||||
|
state->x.next += n;
|
||||||
|
state->x.pos += n;
|
||||||
|
len -= n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* output buffer empty -- return if we're at the end of the input */
|
||||||
|
else if (state->eof && state->strm.avail_in == 0)
|
||||||
|
break;
|
||||||
|
|
||||||
|
/* need more data to skip -- load up output buffer */
|
||||||
|
else {
|
||||||
|
/* get more output, looking for header if required */
|
||||||
|
if (gz_fetch(state) == -1)
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Read len bytes into buf from file, or less than len up to the end of the
|
||||||
|
input. Return the number of bytes read. If zero is returned, either the
|
||||||
|
end of file was reached, or there was an error. state->err must be
|
||||||
|
consulted in that case to determine which. */
|
||||||
|
local z_size_t gz_read(state, buf, len)
|
||||||
|
gz_statep state;
|
||||||
|
voidp buf;
|
||||||
|
z_size_t len;
|
||||||
|
{
|
||||||
|
z_size_t got;
|
||||||
|
unsigned n;
|
||||||
|
|
||||||
|
/* if len is zero, avoid unnecessary operations */
|
||||||
|
if (len == 0)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/* process a skip request */
|
||||||
|
if (state->seek) {
|
||||||
|
state->seek = 0;
|
||||||
|
if (gz_skip(state, state->skip) == -1)
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* get len bytes to buf, or less than len if at the end */
|
||||||
|
got = 0;
|
||||||
|
do {
|
||||||
|
/* set n to the maximum amount of len that fits in an unsigned int */
|
||||||
|
n = (unsigned)-1;
|
||||||
|
if (n > len)
|
||||||
|
n = (unsigned)len;
|
||||||
|
|
||||||
|
/* first just try copying data from the output buffer */
|
||||||
|
if (state->x.have) {
|
||||||
|
if (state->x.have < n)
|
||||||
|
n = state->x.have;
|
||||||
|
memcpy(buf, state->x.next, n);
|
||||||
|
state->x.next += n;
|
||||||
|
state->x.have -= n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* output buffer empty -- return if we're at the end of the input */
|
||||||
|
else if (state->eof && state->strm.avail_in == 0) {
|
||||||
|
state->past = 1; /* tried to read past end */
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* need output data -- for small len or new stream load up our output
|
||||||
|
buffer */
|
||||||
|
else if (state->how == LOOK || n < (state->size << 1)) {
|
||||||
|
/* get more output, looking for header if required */
|
||||||
|
if (gz_fetch(state) == -1)
|
||||||
|
return 0;
|
||||||
|
continue; /* no progress yet -- go back to copy above */
|
||||||
|
/* the copy above assures that we will leave with space in the
|
||||||
|
output buffer, allowing at least one gzungetc() to succeed */
|
||||||
|
}
|
||||||
|
|
||||||
|
/* large len -- read directly into user buffer */
|
||||||
|
else if (state->how == COPY) { /* read directly */
|
||||||
|
if (gz_load(state, (unsigned char *)buf, n, &n) == -1)
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* large len -- decompress directly into user buffer */
|
||||||
|
else { /* state->how == GZIP */
|
||||||
|
state->strm.avail_out = n;
|
||||||
|
state->strm.next_out = (unsigned char *)buf;
|
||||||
|
if (gz_decomp(state) == -1)
|
||||||
|
return 0;
|
||||||
|
n = state->x.have;
|
||||||
|
state->x.have = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* update progress */
|
||||||
|
len -= n;
|
||||||
|
buf = (char *)buf + n;
|
||||||
|
got += n;
|
||||||
|
state->x.pos += n;
|
||||||
|
} while (len);
|
||||||
|
|
||||||
|
/* return number of bytes read into user buffer */
|
||||||
|
return got;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzread(file, buf, len)
|
||||||
|
gzFile file;
|
||||||
|
voidp buf;
|
||||||
|
unsigned len;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return -1;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're reading and that there's no (serious) error */
|
||||||
|
if (state->mode != GZ_READ ||
|
||||||
|
(state->err != Z_OK && state->err != Z_BUF_ERROR))
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* since an int is returned, make sure len fits in one, otherwise return
|
||||||
|
with an error (this avoids a flaw in the interface) */
|
||||||
|
if ((int)len < 0) {
|
||||||
|
gz_error(state, Z_STREAM_ERROR, "request does not fit in an int");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* read len or fewer bytes to buf */
|
||||||
|
len = (unsigned)gz_read(state, buf, len);
|
||||||
|
|
||||||
|
/* check for an error */
|
||||||
|
if (len == 0 && state->err != Z_OK && state->err != Z_BUF_ERROR)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* return the number of bytes read (this is assured to fit in an int) */
|
||||||
|
return (int)len;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
z_size_t ZEXPORT gzfread(buf, size, nitems, file)
|
||||||
|
voidp buf;
|
||||||
|
z_size_t size;
|
||||||
|
z_size_t nitems;
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
z_size_t len;
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return 0;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're reading and that there's no (serious) error */
|
||||||
|
if (state->mode != GZ_READ ||
|
||||||
|
(state->err != Z_OK && state->err != Z_BUF_ERROR))
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/* compute bytes to read -- error on overflow */
|
||||||
|
len = nitems * size;
|
||||||
|
if (size && len / size != nitems) {
|
||||||
|
gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* read len or fewer bytes to buf, return the number of full items read */
|
||||||
|
return len ? gz_read(state, buf, len) / size : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
#ifdef Z_PREFIX_SET
|
||||||
|
# undef z_gzgetc
|
||||||
|
#else
|
||||||
|
# undef gzgetc
|
||||||
|
#endif
|
||||||
|
int ZEXPORT gzgetc(file)
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
unsigned char buf[1];
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return -1;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're reading and that there's no (serious) error */
|
||||||
|
if (state->mode != GZ_READ ||
|
||||||
|
(state->err != Z_OK && state->err != Z_BUF_ERROR))
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* try output buffer (no need to check for skip request) */
|
||||||
|
if (state->x.have) {
|
||||||
|
state->x.have--;
|
||||||
|
state->x.pos++;
|
||||||
|
return *(state->x.next)++;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* nothing there -- try gz_read() */
|
||||||
|
return gz_read(state, buf, 1) < 1 ? -1 : buf[0];
|
||||||
|
}
|
||||||
|
|
||||||
|
int ZEXPORT gzgetc_(file)
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
return gzgetc(file);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzungetc(c, file)
|
||||||
|
int c;
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return -1;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're reading and that there's no (serious) error */
|
||||||
|
if (state->mode != GZ_READ ||
|
||||||
|
(state->err != Z_OK && state->err != Z_BUF_ERROR))
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* process a skip request */
|
||||||
|
if (state->seek) {
|
||||||
|
state->seek = 0;
|
||||||
|
if (gz_skip(state, state->skip) == -1)
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* can't push EOF */
|
||||||
|
if (c < 0)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* if output buffer empty, put byte at end (allows more pushing) */
|
||||||
|
if (state->x.have == 0) {
|
||||||
|
state->x.have = 1;
|
||||||
|
state->x.next = state->out + (state->size << 1) - 1;
|
||||||
|
state->x.next[0] = (unsigned char)c;
|
||||||
|
state->x.pos--;
|
||||||
|
state->past = 0;
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* if no room, give up (must have already done a gzungetc()) */
|
||||||
|
if (state->x.have == (state->size << 1)) {
|
||||||
|
gz_error(state, Z_DATA_ERROR, "out of room to push characters");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* slide output data if needed and insert byte before existing data */
|
||||||
|
if (state->x.next == state->out) {
|
||||||
|
unsigned char *src = state->out + state->x.have;
|
||||||
|
unsigned char *dest = state->out + (state->size << 1);
|
||||||
|
while (src > state->out)
|
||||||
|
*--dest = *--src;
|
||||||
|
state->x.next = dest;
|
||||||
|
}
|
||||||
|
state->x.have++;
|
||||||
|
state->x.next--;
|
||||||
|
state->x.next[0] = (unsigned char)c;
|
||||||
|
state->x.pos--;
|
||||||
|
state->past = 0;
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
char * ZEXPORT gzgets(file, buf, len)
|
||||||
|
gzFile file;
|
||||||
|
char *buf;
|
||||||
|
int len;
|
||||||
|
{
|
||||||
|
unsigned left, n;
|
||||||
|
char *str;
|
||||||
|
unsigned char *eol;
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* check parameters and get internal structure */
|
||||||
|
if (file == NULL || buf == NULL || len < 1)
|
||||||
|
return NULL;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're reading and that there's no (serious) error */
|
||||||
|
if (state->mode != GZ_READ ||
|
||||||
|
(state->err != Z_OK && state->err != Z_BUF_ERROR))
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
/* process a skip request */
|
||||||
|
if (state->seek) {
|
||||||
|
state->seek = 0;
|
||||||
|
if (gz_skip(state, state->skip) == -1)
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* copy output bytes up to new line or len - 1, whichever comes first --
|
||||||
|
append a terminating zero to the string (we don't check for a zero in
|
||||||
|
the contents, let the user worry about that) */
|
||||||
|
str = buf;
|
||||||
|
left = (unsigned)len - 1;
|
||||||
|
if (left) do {
|
||||||
|
/* assure that something is in the output buffer */
|
||||||
|
if (state->x.have == 0 && gz_fetch(state) == -1)
|
||||||
|
return NULL; /* error */
|
||||||
|
if (state->x.have == 0) { /* end of file */
|
||||||
|
state->past = 1; /* read past end */
|
||||||
|
break; /* return what we have */
|
||||||
|
}
|
||||||
|
|
||||||
|
/* look for end-of-line in current output buffer */
|
||||||
|
n = state->x.have > left ? left : state->x.have;
|
||||||
|
eol = (unsigned char *)memchr(state->x.next, '\n', n);
|
||||||
|
if (eol != NULL)
|
||||||
|
n = (unsigned)(eol - state->x.next) + 1;
|
||||||
|
|
||||||
|
/* copy through end-of-line, or remainder if not found */
|
||||||
|
memcpy(buf, state->x.next, n);
|
||||||
|
state->x.have -= n;
|
||||||
|
state->x.next += n;
|
||||||
|
state->x.pos += n;
|
||||||
|
left -= n;
|
||||||
|
buf += n;
|
||||||
|
} while (left && eol == NULL);
|
||||||
|
|
||||||
|
/* return terminated string, or if nothing, end of file */
|
||||||
|
if (buf == str)
|
||||||
|
return NULL;
|
||||||
|
buf[0] = 0;
|
||||||
|
return str;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzdirect(file)
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return 0;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* if the state is not known, but we can find out, then do so (this is
|
||||||
|
mainly for right after a gzopen() or gzdopen()) */
|
||||||
|
if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0)
|
||||||
|
(void)gz_look(state);
|
||||||
|
|
||||||
|
/* return 1 if transparent, 0 if processing a gzip stream */
|
||||||
|
return state->direct;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzclose_r(file)
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
int ret, err;
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're reading */
|
||||||
|
if (state->mode != GZ_READ)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
|
||||||
|
/* free memory and close file */
|
||||||
|
if (state->size) {
|
||||||
|
inflateEnd(&(state->strm));
|
||||||
|
free(state->out);
|
||||||
|
free(state->in);
|
||||||
|
}
|
||||||
|
err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK;
|
||||||
|
gz_error(state, Z_OK, NULL);
|
||||||
|
free(state->path);
|
||||||
|
ret = close(state->fd);
|
||||||
|
free(state);
|
||||||
|
return ret ? Z_ERRNO : err;
|
||||||
|
}
|
677
libraries/zlib/gzwrite.c
Normal file
677
libraries/zlib/gzwrite.c
Normal file
@ -0,0 +1,677 @@
|
|||||||
|
/* gzwrite.c -- zlib functions for writing gzip files
|
||||||
|
* Copyright (C) 2004-2019 Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "gzguts.h"
|
||||||
|
|
||||||
|
/* Local functions */
|
||||||
|
local int gz_init OF((gz_statep));
|
||||||
|
local int gz_comp OF((gz_statep, int));
|
||||||
|
local int gz_zero OF((gz_statep, z_off64_t));
|
||||||
|
local z_size_t gz_write OF((gz_statep, voidpc, z_size_t));
|
||||||
|
|
||||||
|
/* Initialize state for writing a gzip file. Mark initialization by setting
|
||||||
|
state->size to non-zero. Return -1 on a memory allocation failure, or 0 on
|
||||||
|
success. */
|
||||||
|
local int gz_init(state)
|
||||||
|
gz_statep state;
|
||||||
|
{
|
||||||
|
int ret;
|
||||||
|
z_streamp strm = &(state->strm);
|
||||||
|
|
||||||
|
/* allocate input buffer (double size for gzprintf) */
|
||||||
|
state->in = (unsigned char *)malloc(state->want << 1);
|
||||||
|
if (state->in == NULL) {
|
||||||
|
gz_error(state, Z_MEM_ERROR, "out of memory");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* only need output buffer and deflate state if compressing */
|
||||||
|
if (!state->direct) {
|
||||||
|
/* allocate output buffer */
|
||||||
|
state->out = (unsigned char *)malloc(state->want);
|
||||||
|
if (state->out == NULL) {
|
||||||
|
free(state->in);
|
||||||
|
gz_error(state, Z_MEM_ERROR, "out of memory");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* allocate deflate memory, set up for gzip compression */
|
||||||
|
strm->zalloc = Z_NULL;
|
||||||
|
strm->zfree = Z_NULL;
|
||||||
|
strm->opaque = Z_NULL;
|
||||||
|
ret = deflateInit2(strm, state->level, Z_DEFLATED,
|
||||||
|
MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
|
||||||
|
if (ret != Z_OK) {
|
||||||
|
free(state->out);
|
||||||
|
free(state->in);
|
||||||
|
gz_error(state, Z_MEM_ERROR, "out of memory");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
strm->next_in = NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* mark state as initialized */
|
||||||
|
state->size = state->want;
|
||||||
|
|
||||||
|
/* initialize write buffer if compressing */
|
||||||
|
if (!state->direct) {
|
||||||
|
strm->avail_out = state->size;
|
||||||
|
strm->next_out = state->out;
|
||||||
|
state->x.next = strm->next_out;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Compress whatever is at avail_in and next_in and write to the output file.
|
||||||
|
Return -1 if there is an error writing to the output file or if gz_init()
|
||||||
|
fails to allocate memory, otherwise 0. flush is assumed to be a valid
|
||||||
|
deflate() flush value. If flush is Z_FINISH, then the deflate() state is
|
||||||
|
reset to start a new gzip stream. If gz->direct is true, then simply write
|
||||||
|
to the output file without compressing, and ignore flush. */
|
||||||
|
local int gz_comp(state, flush)
|
||||||
|
gz_statep state;
|
||||||
|
int flush;
|
||||||
|
{
|
||||||
|
int ret, writ;
|
||||||
|
unsigned have, put, max = ((unsigned)-1 >> 2) + 1;
|
||||||
|
z_streamp strm = &(state->strm);
|
||||||
|
|
||||||
|
/* allocate memory if this is the first time through */
|
||||||
|
if (state->size == 0 && gz_init(state) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* write directly if requested */
|
||||||
|
if (state->direct) {
|
||||||
|
while (strm->avail_in) {
|
||||||
|
put = strm->avail_in > max ? max : strm->avail_in;
|
||||||
|
writ = write(state->fd, strm->next_in, put);
|
||||||
|
if (writ < 0) {
|
||||||
|
gz_error(state, Z_ERRNO, zstrerror());
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
strm->avail_in -= (unsigned)writ;
|
||||||
|
strm->next_in += writ;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* check for a pending reset */
|
||||||
|
if (state->reset) {
|
||||||
|
/* don't start a new gzip member unless there is data to write */
|
||||||
|
if (strm->avail_in == 0)
|
||||||
|
return 0;
|
||||||
|
deflateReset(strm);
|
||||||
|
state->reset = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* run deflate() on provided input until it produces no more output */
|
||||||
|
ret = Z_OK;
|
||||||
|
do {
|
||||||
|
/* write out current buffer contents if full, or if flushing, but if
|
||||||
|
doing Z_FINISH then don't write until we get to Z_STREAM_END */
|
||||||
|
if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
|
||||||
|
(flush != Z_FINISH || ret == Z_STREAM_END))) {
|
||||||
|
while (strm->next_out > state->x.next) {
|
||||||
|
put = strm->next_out - state->x.next > (int)max ? max :
|
||||||
|
(unsigned)(strm->next_out - state->x.next);
|
||||||
|
writ = write(state->fd, state->x.next, put);
|
||||||
|
if (writ < 0) {
|
||||||
|
gz_error(state, Z_ERRNO, zstrerror());
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
state->x.next += writ;
|
||||||
|
}
|
||||||
|
if (strm->avail_out == 0) {
|
||||||
|
strm->avail_out = state->size;
|
||||||
|
strm->next_out = state->out;
|
||||||
|
state->x.next = state->out;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* compress */
|
||||||
|
have = strm->avail_out;
|
||||||
|
ret = deflate(strm, flush);
|
||||||
|
if (ret == Z_STREAM_ERROR) {
|
||||||
|
gz_error(state, Z_STREAM_ERROR,
|
||||||
|
"internal error: deflate stream corrupt");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
have -= strm->avail_out;
|
||||||
|
} while (have);
|
||||||
|
|
||||||
|
/* if that completed a deflate stream, allow another to start */
|
||||||
|
if (flush == Z_FINISH)
|
||||||
|
state->reset = 1;
|
||||||
|
|
||||||
|
/* all done, no errors */
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Compress len zeros to output. Return -1 on a write error or memory
|
||||||
|
allocation failure by gz_comp(), or 0 on success. */
|
||||||
|
local int gz_zero(state, len)
|
||||||
|
gz_statep state;
|
||||||
|
z_off64_t len;
|
||||||
|
{
|
||||||
|
int first;
|
||||||
|
unsigned n;
|
||||||
|
z_streamp strm = &(state->strm);
|
||||||
|
|
||||||
|
/* consume whatever's left in the input buffer */
|
||||||
|
if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* compress len zeros (len guaranteed > 0) */
|
||||||
|
first = 1;
|
||||||
|
while (len) {
|
||||||
|
n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
|
||||||
|
(unsigned)len : state->size;
|
||||||
|
if (first) {
|
||||||
|
memset(state->in, 0, n);
|
||||||
|
first = 0;
|
||||||
|
}
|
||||||
|
strm->avail_in = n;
|
||||||
|
strm->next_in = state->in;
|
||||||
|
state->x.pos += n;
|
||||||
|
if (gz_comp(state, Z_NO_FLUSH) == -1)
|
||||||
|
return -1;
|
||||||
|
len -= n;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Write len bytes from buf to file. Return the number of bytes written. If
|
||||||
|
the returned value is less than len, then there was an error. */
|
||||||
|
local z_size_t gz_write(state, buf, len)
|
||||||
|
gz_statep state;
|
||||||
|
voidpc buf;
|
||||||
|
z_size_t len;
|
||||||
|
{
|
||||||
|
z_size_t put = len;
|
||||||
|
|
||||||
|
/* if len is zero, avoid unnecessary operations */
|
||||||
|
if (len == 0)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/* allocate memory if this is the first time through */
|
||||||
|
if (state->size == 0 && gz_init(state) == -1)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/* check for seek request */
|
||||||
|
if (state->seek) {
|
||||||
|
state->seek = 0;
|
||||||
|
if (gz_zero(state, state->skip) == -1)
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* for small len, copy to input buffer, otherwise compress directly */
|
||||||
|
if (len < state->size) {
|
||||||
|
/* copy to input buffer, compress when full */
|
||||||
|
do {
|
||||||
|
unsigned have, copy;
|
||||||
|
|
||||||
|
if (state->strm.avail_in == 0)
|
||||||
|
state->strm.next_in = state->in;
|
||||||
|
have = (unsigned)((state->strm.next_in + state->strm.avail_in) -
|
||||||
|
state->in);
|
||||||
|
copy = state->size - have;
|
||||||
|
if (copy > len)
|
||||||
|
copy = (unsigned)len;
|
||||||
|
memcpy(state->in + have, buf, copy);
|
||||||
|
state->strm.avail_in += copy;
|
||||||
|
state->x.pos += copy;
|
||||||
|
buf = (const char *)buf + copy;
|
||||||
|
len -= copy;
|
||||||
|
if (len && gz_comp(state, Z_NO_FLUSH) == -1)
|
||||||
|
return 0;
|
||||||
|
} while (len);
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
/* consume whatever's left in the input buffer */
|
||||||
|
if (state->strm.avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/* directly compress user buffer to file */
|
||||||
|
state->strm.next_in = (z_const Bytef *)buf;
|
||||||
|
do {
|
||||||
|
unsigned n = (unsigned)-1;
|
||||||
|
if (n > len)
|
||||||
|
n = (unsigned)len;
|
||||||
|
state->strm.avail_in = n;
|
||||||
|
state->x.pos += n;
|
||||||
|
if (gz_comp(state, Z_NO_FLUSH) == -1)
|
||||||
|
return 0;
|
||||||
|
len -= n;
|
||||||
|
} while (len);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* input was all buffered or compressed */
|
||||||
|
return put;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzwrite(file, buf, len)
|
||||||
|
gzFile file;
|
||||||
|
voidpc buf;
|
||||||
|
unsigned len;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return 0;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're writing and that there's no error */
|
||||||
|
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/* since an int is returned, make sure len fits in one, otherwise return
|
||||||
|
with an error (this avoids a flaw in the interface) */
|
||||||
|
if ((int)len < 0) {
|
||||||
|
gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* write len bytes from buf (the return value will fit in an int) */
|
||||||
|
return (int)gz_write(state, buf, len);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
z_size_t ZEXPORT gzfwrite(buf, size, nitems, file)
|
||||||
|
voidpc buf;
|
||||||
|
z_size_t size;
|
||||||
|
z_size_t nitems;
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
z_size_t len;
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return 0;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're writing and that there's no error */
|
||||||
|
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/* compute bytes to read -- error on overflow */
|
||||||
|
len = nitems * size;
|
||||||
|
if (size && len / size != nitems) {
|
||||||
|
gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* write len bytes to buf, return the number of full items written */
|
||||||
|
return len ? gz_write(state, buf, len) / size : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzputc(file, c)
|
||||||
|
gzFile file;
|
||||||
|
int c;
|
||||||
|
{
|
||||||
|
unsigned have;
|
||||||
|
unsigned char buf[1];
|
||||||
|
gz_statep state;
|
||||||
|
z_streamp strm;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return -1;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
strm = &(state->strm);
|
||||||
|
|
||||||
|
/* check that we're writing and that there's no error */
|
||||||
|
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* check for seek request */
|
||||||
|
if (state->seek) {
|
||||||
|
state->seek = 0;
|
||||||
|
if (gz_zero(state, state->skip) == -1)
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* try writing to input buffer for speed (state->size == 0 if buffer not
|
||||||
|
initialized) */
|
||||||
|
if (state->size) {
|
||||||
|
if (strm->avail_in == 0)
|
||||||
|
strm->next_in = state->in;
|
||||||
|
have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
|
||||||
|
if (have < state->size) {
|
||||||
|
state->in[have] = (unsigned char)c;
|
||||||
|
strm->avail_in++;
|
||||||
|
state->x.pos++;
|
||||||
|
return c & 0xff;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* no room in buffer or not initialized, use gz_write() */
|
||||||
|
buf[0] = (unsigned char)c;
|
||||||
|
if (gz_write(state, buf, 1) != 1)
|
||||||
|
return -1;
|
||||||
|
return c & 0xff;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzputs(file, s)
|
||||||
|
gzFile file;
|
||||||
|
const char *s;
|
||||||
|
{
|
||||||
|
z_size_t len, put;
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return -1;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're writing and that there's no error */
|
||||||
|
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
/* write string */
|
||||||
|
len = strlen(s);
|
||||||
|
if ((int)len < 0 || (unsigned)len != len) {
|
||||||
|
gz_error(state, Z_STREAM_ERROR, "string length does not fit in int");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
put = gz_write(state, s, len);
|
||||||
|
return put < len ? -1 : (int)len;
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(STDC) || defined(Z_HAVE_STDARG_H)
|
||||||
|
#include <stdarg.h>
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va)
|
||||||
|
{
|
||||||
|
int len;
|
||||||
|
unsigned left;
|
||||||
|
char *next;
|
||||||
|
gz_statep state;
|
||||||
|
z_streamp strm;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
strm = &(state->strm);
|
||||||
|
|
||||||
|
/* check that we're writing and that there's no error */
|
||||||
|
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
|
||||||
|
/* make sure we have some buffer space */
|
||||||
|
if (state->size == 0 && gz_init(state) == -1)
|
||||||
|
return state->err;
|
||||||
|
|
||||||
|
/* check for seek request */
|
||||||
|
if (state->seek) {
|
||||||
|
state->seek = 0;
|
||||||
|
if (gz_zero(state, state->skip) == -1)
|
||||||
|
return state->err;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* do the printf() into the input buffer, put length in len -- the input
|
||||||
|
buffer is double-sized just for this function, so there is guaranteed to
|
||||||
|
be state->size bytes available after the current contents */
|
||||||
|
if (strm->avail_in == 0)
|
||||||
|
strm->next_in = state->in;
|
||||||
|
next = (char *)(state->in + (strm->next_in - state->in) + strm->avail_in);
|
||||||
|
next[state->size - 1] = 0;
|
||||||
|
#ifdef NO_vsnprintf
|
||||||
|
# ifdef HAS_vsprintf_void
|
||||||
|
(void)vsprintf(next, format, va);
|
||||||
|
for (len = 0; len < state->size; len++)
|
||||||
|
if (next[len] == 0) break;
|
||||||
|
# else
|
||||||
|
len = vsprintf(next, format, va);
|
||||||
|
# endif
|
||||||
|
#else
|
||||||
|
# ifdef HAS_vsnprintf_void
|
||||||
|
(void)vsnprintf(next, state->size, format, va);
|
||||||
|
len = strlen(next);
|
||||||
|
# else
|
||||||
|
len = vsnprintf(next, state->size, format, va);
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* check that printf() results fit in buffer */
|
||||||
|
if (len == 0 || (unsigned)len >= state->size || next[state->size - 1] != 0)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/* update buffer and position, compress first half if past that */
|
||||||
|
strm->avail_in += (unsigned)len;
|
||||||
|
state->x.pos += len;
|
||||||
|
if (strm->avail_in >= state->size) {
|
||||||
|
left = strm->avail_in - state->size;
|
||||||
|
strm->avail_in = state->size;
|
||||||
|
if (gz_comp(state, Z_NO_FLUSH) == -1)
|
||||||
|
return state->err;
|
||||||
|
memmove(state->in, state->in + state->size, left);
|
||||||
|
strm->next_in = state->in;
|
||||||
|
strm->avail_in = left;
|
||||||
|
}
|
||||||
|
return len;
|
||||||
|
}
|
||||||
|
|
||||||
|
int ZEXPORTVA gzprintf(gzFile file, const char *format, ...)
|
||||||
|
{
|
||||||
|
va_list va;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
va_start(va, format);
|
||||||
|
ret = gzvprintf(file, format, va);
|
||||||
|
va_end(va);
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
#else /* !STDC && !Z_HAVE_STDARG_H */
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
|
||||||
|
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
|
||||||
|
gzFile file;
|
||||||
|
const char *format;
|
||||||
|
int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
|
||||||
|
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
|
||||||
|
{
|
||||||
|
unsigned len, left;
|
||||||
|
char *next;
|
||||||
|
gz_statep state;
|
||||||
|
z_streamp strm;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
strm = &(state->strm);
|
||||||
|
|
||||||
|
/* check that can really pass pointer in ints */
|
||||||
|
if (sizeof(int) != sizeof(void *))
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
|
||||||
|
/* check that we're writing and that there's no error */
|
||||||
|
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
|
||||||
|
/* make sure we have some buffer space */
|
||||||
|
if (state->size == 0 && gz_init(state) == -1)
|
||||||
|
return state->error;
|
||||||
|
|
||||||
|
/* check for seek request */
|
||||||
|
if (state->seek) {
|
||||||
|
state->seek = 0;
|
||||||
|
if (gz_zero(state, state->skip) == -1)
|
||||||
|
return state->error;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* do the printf() into the input buffer, put length in len -- the input
|
||||||
|
buffer is double-sized just for this function, so there is guaranteed to
|
||||||
|
be state->size bytes available after the current contents */
|
||||||
|
if (strm->avail_in == 0)
|
||||||
|
strm->next_in = state->in;
|
||||||
|
next = (char *)(strm->next_in + strm->avail_in);
|
||||||
|
next[state->size - 1] = 0;
|
||||||
|
#ifdef NO_snprintf
|
||||||
|
# ifdef HAS_sprintf_void
|
||||||
|
sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12,
|
||||||
|
a13, a14, a15, a16, a17, a18, a19, a20);
|
||||||
|
for (len = 0; len < size; len++)
|
||||||
|
if (next[len] == 0)
|
||||||
|
break;
|
||||||
|
# else
|
||||||
|
len = sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
|
||||||
|
a12, a13, a14, a15, a16, a17, a18, a19, a20);
|
||||||
|
# endif
|
||||||
|
#else
|
||||||
|
# ifdef HAS_snprintf_void
|
||||||
|
snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8, a9,
|
||||||
|
a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
|
||||||
|
len = strlen(next);
|
||||||
|
# else
|
||||||
|
len = snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8,
|
||||||
|
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* check that printf() results fit in buffer */
|
||||||
|
if (len == 0 || len >= state->size || next[state->size - 1] != 0)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
/* update buffer and position, compress first half if past that */
|
||||||
|
strm->avail_in += len;
|
||||||
|
state->x.pos += len;
|
||||||
|
if (strm->avail_in >= state->size) {
|
||||||
|
left = strm->avail_in - state->size;
|
||||||
|
strm->avail_in = state->size;
|
||||||
|
if (gz_comp(state, Z_NO_FLUSH) == -1)
|
||||||
|
return state->err;
|
||||||
|
memmove(state->in, state->in + state->size, left);
|
||||||
|
strm->next_in = state->in;
|
||||||
|
strm->avail_in = left;
|
||||||
|
}
|
||||||
|
return (int)len;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzflush(file, flush)
|
||||||
|
gzFile file;
|
||||||
|
int flush;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're writing and that there's no error */
|
||||||
|
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
|
||||||
|
/* check flush parameter */
|
||||||
|
if (flush < 0 || flush > Z_FINISH)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
|
||||||
|
/* check for seek request */
|
||||||
|
if (state->seek) {
|
||||||
|
state->seek = 0;
|
||||||
|
if (gz_zero(state, state->skip) == -1)
|
||||||
|
return state->err;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* compress remaining data with requested flush */
|
||||||
|
(void)gz_comp(state, flush);
|
||||||
|
return state->err;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzsetparams(file, level, strategy)
|
||||||
|
gzFile file;
|
||||||
|
int level;
|
||||||
|
int strategy;
|
||||||
|
{
|
||||||
|
gz_statep state;
|
||||||
|
z_streamp strm;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
strm = &(state->strm);
|
||||||
|
|
||||||
|
/* check that we're writing and that there's no error */
|
||||||
|
if (state->mode != GZ_WRITE || state->err != Z_OK)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
|
||||||
|
/* if no change is requested, then do nothing */
|
||||||
|
if (level == state->level && strategy == state->strategy)
|
||||||
|
return Z_OK;
|
||||||
|
|
||||||
|
/* check for seek request */
|
||||||
|
if (state->seek) {
|
||||||
|
state->seek = 0;
|
||||||
|
if (gz_zero(state, state->skip) == -1)
|
||||||
|
return state->err;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* change compression parameters for subsequent input */
|
||||||
|
if (state->size) {
|
||||||
|
/* flush previous input with previous parameters before changing */
|
||||||
|
if (strm->avail_in && gz_comp(state, Z_BLOCK) == -1)
|
||||||
|
return state->err;
|
||||||
|
deflateParams(strm, level, strategy);
|
||||||
|
}
|
||||||
|
state->level = level;
|
||||||
|
state->strategy = strategy;
|
||||||
|
return Z_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* -- see zlib.h -- */
|
||||||
|
int ZEXPORT gzclose_w(file)
|
||||||
|
gzFile file;
|
||||||
|
{
|
||||||
|
int ret = Z_OK;
|
||||||
|
gz_statep state;
|
||||||
|
|
||||||
|
/* get internal structure */
|
||||||
|
if (file == NULL)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
state = (gz_statep)file;
|
||||||
|
|
||||||
|
/* check that we're writing */
|
||||||
|
if (state->mode != GZ_WRITE)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
|
||||||
|
/* check for seek request */
|
||||||
|
if (state->seek) {
|
||||||
|
state->seek = 0;
|
||||||
|
if (gz_zero(state, state->skip) == -1)
|
||||||
|
ret = state->err;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* flush, free memory, and close file */
|
||||||
|
if (gz_comp(state, Z_FINISH) == -1)
|
||||||
|
ret = state->err;
|
||||||
|
if (state->size) {
|
||||||
|
if (!state->direct) {
|
||||||
|
(void)deflateEnd(&(state->strm));
|
||||||
|
free(state->out);
|
||||||
|
}
|
||||||
|
free(state->in);
|
||||||
|
}
|
||||||
|
gz_error(state, Z_OK, NULL);
|
||||||
|
free(state->path);
|
||||||
|
if (close(state->fd) == -1)
|
||||||
|
ret = Z_ERRNO;
|
||||||
|
free(state);
|
||||||
|
return ret;
|
||||||
|
}
|
641
libraries/zlib/infback.c
Normal file
641
libraries/zlib/infback.c
Normal file
@ -0,0 +1,641 @@
|
|||||||
|
/* infback.c -- inflate using a call-back interface
|
||||||
|
* Copyright (C) 1995-2022 Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
This code is largely copied from inflate.c. Normally either infback.o or
|
||||||
|
inflate.o would be linked into an application--not both. The interface
|
||||||
|
with inffast.c is retained so that optimized assembler-coded versions of
|
||||||
|
inflate_fast() can be used with either inflate.c or infback.c.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "zutil.h"
|
||||||
|
#include "inftrees.h"
|
||||||
|
#include "inflate.h"
|
||||||
|
#include "inffast.h"
|
||||||
|
|
||||||
|
/* function prototypes */
|
||||||
|
local void fixedtables OF((struct inflate_state FAR *state));
|
||||||
|
|
||||||
|
/*
|
||||||
|
strm provides memory allocation functions in zalloc and zfree, or
|
||||||
|
Z_NULL to use the library memory allocation functions.
|
||||||
|
|
||||||
|
windowBits is in the range 8..15, and window is a user-supplied
|
||||||
|
window and output buffer that is 2**windowBits bytes.
|
||||||
|
*/
|
||||||
|
int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
|
||||||
|
z_streamp strm;
|
||||||
|
int windowBits;
|
||||||
|
unsigned char FAR *window;
|
||||||
|
const char *version;
|
||||||
|
int stream_size;
|
||||||
|
{
|
||||||
|
struct inflate_state FAR *state;
|
||||||
|
|
||||||
|
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
|
||||||
|
stream_size != (int)(sizeof(z_stream)))
|
||||||
|
return Z_VERSION_ERROR;
|
||||||
|
if (strm == Z_NULL || window == Z_NULL ||
|
||||||
|
windowBits < 8 || windowBits > 15)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
strm->msg = Z_NULL; /* in case we return an error */
|
||||||
|
if (strm->zalloc == (alloc_func)0) {
|
||||||
|
#ifdef Z_SOLO
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
#else
|
||||||
|
strm->zalloc = zcalloc;
|
||||||
|
strm->opaque = (voidpf)0;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
if (strm->zfree == (free_func)0)
|
||||||
|
#ifdef Z_SOLO
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
#else
|
||||||
|
strm->zfree = zcfree;
|
||||||
|
#endif
|
||||||
|
state = (struct inflate_state FAR *)ZALLOC(strm, 1,
|
||||||
|
sizeof(struct inflate_state));
|
||||||
|
if (state == Z_NULL) return Z_MEM_ERROR;
|
||||||
|
Tracev((stderr, "inflate: allocated\n"));
|
||||||
|
strm->state = (struct internal_state FAR *)state;
|
||||||
|
state->dmax = 32768U;
|
||||||
|
state->wbits = (uInt)windowBits;
|
||||||
|
state->wsize = 1U << windowBits;
|
||||||
|
state->window = window;
|
||||||
|
state->wnext = 0;
|
||||||
|
state->whave = 0;
|
||||||
|
return Z_OK;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
Return state with length and distance decoding tables and index sizes set to
|
||||||
|
fixed code decoding. Normally this returns fixed tables from inffixed.h.
|
||||||
|
If BUILDFIXED is defined, then instead this routine builds the tables the
|
||||||
|
first time it's called, and returns those tables the first time and
|
||||||
|
thereafter. This reduces the size of the code by about 2K bytes, in
|
||||||
|
exchange for a little execution time. However, BUILDFIXED should not be
|
||||||
|
used for threaded applications, since the rewriting of the tables and virgin
|
||||||
|
may not be thread-safe.
|
||||||
|
*/
|
||||||
|
local void fixedtables(state)
|
||||||
|
struct inflate_state FAR *state;
|
||||||
|
{
|
||||||
|
#ifdef BUILDFIXED
|
||||||
|
static int virgin = 1;
|
||||||
|
static code *lenfix, *distfix;
|
||||||
|
static code fixed[544];
|
||||||
|
|
||||||
|
/* build fixed huffman tables if first call (may not be thread safe) */
|
||||||
|
if (virgin) {
|
||||||
|
unsigned sym, bits;
|
||||||
|
static code *next;
|
||||||
|
|
||||||
|
/* literal/length table */
|
||||||
|
sym = 0;
|
||||||
|
while (sym < 144) state->lens[sym++] = 8;
|
||||||
|
while (sym < 256) state->lens[sym++] = 9;
|
||||||
|
while (sym < 280) state->lens[sym++] = 7;
|
||||||
|
while (sym < 288) state->lens[sym++] = 8;
|
||||||
|
next = fixed;
|
||||||
|
lenfix = next;
|
||||||
|
bits = 9;
|
||||||
|
inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
|
||||||
|
|
||||||
|
/* distance table */
|
||||||
|
sym = 0;
|
||||||
|
while (sym < 32) state->lens[sym++] = 5;
|
||||||
|
distfix = next;
|
||||||
|
bits = 5;
|
||||||
|
inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
|
||||||
|
|
||||||
|
/* do this just once */
|
||||||
|
virgin = 0;
|
||||||
|
}
|
||||||
|
#else /* !BUILDFIXED */
|
||||||
|
# include "inffixed.h"
|
||||||
|
#endif /* BUILDFIXED */
|
||||||
|
state->lencode = lenfix;
|
||||||
|
state->lenbits = 9;
|
||||||
|
state->distcode = distfix;
|
||||||
|
state->distbits = 5;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Macros for inflateBack(): */
|
||||||
|
|
||||||
|
/* Load returned state from inflate_fast() */
|
||||||
|
#define LOAD() \
|
||||||
|
do { \
|
||||||
|
put = strm->next_out; \
|
||||||
|
left = strm->avail_out; \
|
||||||
|
next = strm->next_in; \
|
||||||
|
have = strm->avail_in; \
|
||||||
|
hold = state->hold; \
|
||||||
|
bits = state->bits; \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/* Set state from registers for inflate_fast() */
|
||||||
|
#define RESTORE() \
|
||||||
|
do { \
|
||||||
|
strm->next_out = put; \
|
||||||
|
strm->avail_out = left; \
|
||||||
|
strm->next_in = next; \
|
||||||
|
strm->avail_in = have; \
|
||||||
|
state->hold = hold; \
|
||||||
|
state->bits = bits; \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/* Clear the input bit accumulator */
|
||||||
|
#define INITBITS() \
|
||||||
|
do { \
|
||||||
|
hold = 0; \
|
||||||
|
bits = 0; \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/* Assure that some input is available. If input is requested, but denied,
|
||||||
|
then return a Z_BUF_ERROR from inflateBack(). */
|
||||||
|
#define PULL() \
|
||||||
|
do { \
|
||||||
|
if (have == 0) { \
|
||||||
|
have = in(in_desc, &next); \
|
||||||
|
if (have == 0) { \
|
||||||
|
next = Z_NULL; \
|
||||||
|
ret = Z_BUF_ERROR; \
|
||||||
|
goto inf_leave; \
|
||||||
|
} \
|
||||||
|
} \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/* Get a byte of input into the bit accumulator, or return from inflateBack()
|
||||||
|
with an error if there is no input available. */
|
||||||
|
#define PULLBYTE() \
|
||||||
|
do { \
|
||||||
|
PULL(); \
|
||||||
|
have--; \
|
||||||
|
hold += (unsigned long)(*next++) << bits; \
|
||||||
|
bits += 8; \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/* Assure that there are at least n bits in the bit accumulator. If there is
|
||||||
|
not enough available input to do that, then return from inflateBack() with
|
||||||
|
an error. */
|
||||||
|
#define NEEDBITS(n) \
|
||||||
|
do { \
|
||||||
|
while (bits < (unsigned)(n)) \
|
||||||
|
PULLBYTE(); \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/* Return the low n bits of the bit accumulator (n < 16) */
|
||||||
|
#define BITS(n) \
|
||||||
|
((unsigned)hold & ((1U << (n)) - 1))
|
||||||
|
|
||||||
|
/* Remove n bits from the bit accumulator */
|
||||||
|
#define DROPBITS(n) \
|
||||||
|
do { \
|
||||||
|
hold >>= (n); \
|
||||||
|
bits -= (unsigned)(n); \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/* Remove zero to seven bits as needed to go to a byte boundary */
|
||||||
|
#define BYTEBITS() \
|
||||||
|
do { \
|
||||||
|
hold >>= bits & 7; \
|
||||||
|
bits -= bits & 7; \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/* Assure that some output space is available, by writing out the window
|
||||||
|
if it's full. If the write fails, return from inflateBack() with a
|
||||||
|
Z_BUF_ERROR. */
|
||||||
|
#define ROOM() \
|
||||||
|
do { \
|
||||||
|
if (left == 0) { \
|
||||||
|
put = state->window; \
|
||||||
|
left = state->wsize; \
|
||||||
|
state->whave = left; \
|
||||||
|
if (out(out_desc, put, left)) { \
|
||||||
|
ret = Z_BUF_ERROR; \
|
||||||
|
goto inf_leave; \
|
||||||
|
} \
|
||||||
|
} \
|
||||||
|
} while (0)
|
||||||
|
|
||||||
|
/*
|
||||||
|
strm provides the memory allocation functions and window buffer on input,
|
||||||
|
and provides information on the unused input on return. For Z_DATA_ERROR
|
||||||
|
returns, strm will also provide an error message.
|
||||||
|
|
||||||
|
in() and out() are the call-back input and output functions. When
|
||||||
|
inflateBack() needs more input, it calls in(). When inflateBack() has
|
||||||
|
filled the window with output, or when it completes with data in the
|
||||||
|
window, it calls out() to write out the data. The application must not
|
||||||
|
change the provided input until in() is called again or inflateBack()
|
||||||
|
returns. The application must not change the window/output buffer until
|
||||||
|
inflateBack() returns.
|
||||||
|
|
||||||
|
in() and out() are called with a descriptor parameter provided in the
|
||||||
|
inflateBack() call. This parameter can be a structure that provides the
|
||||||
|
information required to do the read or write, as well as accumulated
|
||||||
|
information on the input and output such as totals and check values.
|
||||||
|
|
||||||
|
in() should return zero on failure. out() should return non-zero on
|
||||||
|
failure. If either in() or out() fails, than inflateBack() returns a
|
||||||
|
Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it
|
||||||
|
was in() or out() that caused in the error. Otherwise, inflateBack()
|
||||||
|
returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
|
||||||
|
error, or Z_MEM_ERROR if it could not allocate memory for the state.
|
||||||
|
inflateBack() can also return Z_STREAM_ERROR if the input parameters
|
||||||
|
are not correct, i.e. strm is Z_NULL or the state was not initialized.
|
||||||
|
*/
|
||||||
|
int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
|
||||||
|
z_streamp strm;
|
||||||
|
in_func in;
|
||||||
|
void FAR *in_desc;
|
||||||
|
out_func out;
|
||||||
|
void FAR *out_desc;
|
||||||
|
{
|
||||||
|
struct inflate_state FAR *state;
|
||||||
|
z_const unsigned char FAR *next; /* next input */
|
||||||
|
unsigned char FAR *put; /* next output */
|
||||||
|
unsigned have, left; /* available input and output */
|
||||||
|
unsigned long hold; /* bit buffer */
|
||||||
|
unsigned bits; /* bits in bit buffer */
|
||||||
|
unsigned copy; /* number of stored or match bytes to copy */
|
||||||
|
unsigned char FAR *from; /* where to copy match bytes from */
|
||||||
|
code here; /* current decoding table entry */
|
||||||
|
code last; /* parent table entry */
|
||||||
|
unsigned len; /* length to copy for repeats, bits to drop */
|
||||||
|
int ret; /* return code */
|
||||||
|
static const unsigned short order[19] = /* permutation of code lengths */
|
||||||
|
{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
|
||||||
|
|
||||||
|
/* Check that the strm exists and that the state was initialized */
|
||||||
|
if (strm == Z_NULL || strm->state == Z_NULL)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
|
|
||||||
|
/* Reset the state */
|
||||||
|
strm->msg = Z_NULL;
|
||||||
|
state->mode = TYPE;
|
||||||
|
state->last = 0;
|
||||||
|
state->whave = 0;
|
||||||
|
next = strm->next_in;
|
||||||
|
have = next != Z_NULL ? strm->avail_in : 0;
|
||||||
|
hold = 0;
|
||||||
|
bits = 0;
|
||||||
|
put = state->window;
|
||||||
|
left = state->wsize;
|
||||||
|
|
||||||
|
/* Inflate until end of block marked as last */
|
||||||
|
for (;;)
|
||||||
|
switch (state->mode) {
|
||||||
|
case TYPE:
|
||||||
|
/* determine and dispatch block type */
|
||||||
|
if (state->last) {
|
||||||
|
BYTEBITS();
|
||||||
|
state->mode = DONE;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
NEEDBITS(3);
|
||||||
|
state->last = BITS(1);
|
||||||
|
DROPBITS(1);
|
||||||
|
switch (BITS(2)) {
|
||||||
|
case 0: /* stored block */
|
||||||
|
Tracev((stderr, "inflate: stored block%s\n",
|
||||||
|
state->last ? " (last)" : ""));
|
||||||
|
state->mode = STORED;
|
||||||
|
break;
|
||||||
|
case 1: /* fixed block */
|
||||||
|
fixedtables(state);
|
||||||
|
Tracev((stderr, "inflate: fixed codes block%s\n",
|
||||||
|
state->last ? " (last)" : ""));
|
||||||
|
state->mode = LEN; /* decode codes */
|
||||||
|
break;
|
||||||
|
case 2: /* dynamic block */
|
||||||
|
Tracev((stderr, "inflate: dynamic codes block%s\n",
|
||||||
|
state->last ? " (last)" : ""));
|
||||||
|
state->mode = TABLE;
|
||||||
|
break;
|
||||||
|
case 3:
|
||||||
|
strm->msg = (char *)"invalid block type";
|
||||||
|
state->mode = BAD;
|
||||||
|
}
|
||||||
|
DROPBITS(2);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case STORED:
|
||||||
|
/* get and verify stored block length */
|
||||||
|
BYTEBITS(); /* go to byte boundary */
|
||||||
|
NEEDBITS(32);
|
||||||
|
if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
|
||||||
|
strm->msg = (char *)"invalid stored block lengths";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
state->length = (unsigned)hold & 0xffff;
|
||||||
|
Tracev((stderr, "inflate: stored length %u\n",
|
||||||
|
state->length));
|
||||||
|
INITBITS();
|
||||||
|
|
||||||
|
/* copy stored block from input to output */
|
||||||
|
while (state->length != 0) {
|
||||||
|
copy = state->length;
|
||||||
|
PULL();
|
||||||
|
ROOM();
|
||||||
|
if (copy > have) copy = have;
|
||||||
|
if (copy > left) copy = left;
|
||||||
|
zmemcpy(put, next, copy);
|
||||||
|
have -= copy;
|
||||||
|
next += copy;
|
||||||
|
left -= copy;
|
||||||
|
put += copy;
|
||||||
|
state->length -= copy;
|
||||||
|
}
|
||||||
|
Tracev((stderr, "inflate: stored end\n"));
|
||||||
|
state->mode = TYPE;
|
||||||
|
break;
|
||||||
|
|
||||||
|
case TABLE:
|
||||||
|
/* get dynamic table entries descriptor */
|
||||||
|
NEEDBITS(14);
|
||||||
|
state->nlen = BITS(5) + 257;
|
||||||
|
DROPBITS(5);
|
||||||
|
state->ndist = BITS(5) + 1;
|
||||||
|
DROPBITS(5);
|
||||||
|
state->ncode = BITS(4) + 4;
|
||||||
|
DROPBITS(4);
|
||||||
|
#ifndef PKZIP_BUG_WORKAROUND
|
||||||
|
if (state->nlen > 286 || state->ndist > 30) {
|
||||||
|
strm->msg = (char *)"too many length or distance symbols";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
Tracev((stderr, "inflate: table sizes ok\n"));
|
||||||
|
|
||||||
|
/* get code length code lengths (not a typo) */
|
||||||
|
state->have = 0;
|
||||||
|
while (state->have < state->ncode) {
|
||||||
|
NEEDBITS(3);
|
||||||
|
state->lens[order[state->have++]] = (unsigned short)BITS(3);
|
||||||
|
DROPBITS(3);
|
||||||
|
}
|
||||||
|
while (state->have < 19)
|
||||||
|
state->lens[order[state->have++]] = 0;
|
||||||
|
state->next = state->codes;
|
||||||
|
state->lencode = (code const FAR *)(state->next);
|
||||||
|
state->lenbits = 7;
|
||||||
|
ret = inflate_table(CODES, state->lens, 19, &(state->next),
|
||||||
|
&(state->lenbits), state->work);
|
||||||
|
if (ret) {
|
||||||
|
strm->msg = (char *)"invalid code lengths set";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
Tracev((stderr, "inflate: code lengths ok\n"));
|
||||||
|
|
||||||
|
/* get length and distance code code lengths */
|
||||||
|
state->have = 0;
|
||||||
|
while (state->have < state->nlen + state->ndist) {
|
||||||
|
for (;;) {
|
||||||
|
here = state->lencode[BITS(state->lenbits)];
|
||||||
|
if ((unsigned)(here.bits) <= bits) break;
|
||||||
|
PULLBYTE();
|
||||||
|
}
|
||||||
|
if (here.val < 16) {
|
||||||
|
DROPBITS(here.bits);
|
||||||
|
state->lens[state->have++] = here.val;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
if (here.val == 16) {
|
||||||
|
NEEDBITS(here.bits + 2);
|
||||||
|
DROPBITS(here.bits);
|
||||||
|
if (state->have == 0) {
|
||||||
|
strm->msg = (char *)"invalid bit length repeat";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
len = (unsigned)(state->lens[state->have - 1]);
|
||||||
|
copy = 3 + BITS(2);
|
||||||
|
DROPBITS(2);
|
||||||
|
}
|
||||||
|
else if (here.val == 17) {
|
||||||
|
NEEDBITS(here.bits + 3);
|
||||||
|
DROPBITS(here.bits);
|
||||||
|
len = 0;
|
||||||
|
copy = 3 + BITS(3);
|
||||||
|
DROPBITS(3);
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
NEEDBITS(here.bits + 7);
|
||||||
|
DROPBITS(here.bits);
|
||||||
|
len = 0;
|
||||||
|
copy = 11 + BITS(7);
|
||||||
|
DROPBITS(7);
|
||||||
|
}
|
||||||
|
if (state->have + copy > state->nlen + state->ndist) {
|
||||||
|
strm->msg = (char *)"invalid bit length repeat";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
while (copy--)
|
||||||
|
state->lens[state->have++] = (unsigned short)len;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* handle error breaks in while */
|
||||||
|
if (state->mode == BAD) break;
|
||||||
|
|
||||||
|
/* check for end-of-block code (better have one) */
|
||||||
|
if (state->lens[256] == 0) {
|
||||||
|
strm->msg = (char *)"invalid code -- missing end-of-block";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* build code tables -- note: do not change the lenbits or distbits
|
||||||
|
values here (9 and 6) without reading the comments in inftrees.h
|
||||||
|
concerning the ENOUGH constants, which depend on those values */
|
||||||
|
state->next = state->codes;
|
||||||
|
state->lencode = (code const FAR *)(state->next);
|
||||||
|
state->lenbits = 9;
|
||||||
|
ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
|
||||||
|
&(state->lenbits), state->work);
|
||||||
|
if (ret) {
|
||||||
|
strm->msg = (char *)"invalid literal/lengths set";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
state->distcode = (code const FAR *)(state->next);
|
||||||
|
state->distbits = 6;
|
||||||
|
ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
|
||||||
|
&(state->next), &(state->distbits), state->work);
|
||||||
|
if (ret) {
|
||||||
|
strm->msg = (char *)"invalid distances set";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
Tracev((stderr, "inflate: codes ok\n"));
|
||||||
|
state->mode = LEN;
|
||||||
|
/* fallthrough */
|
||||||
|
|
||||||
|
case LEN:
|
||||||
|
/* use inflate_fast() if we have enough input and output */
|
||||||
|
if (have >= 6 && left >= 258) {
|
||||||
|
RESTORE();
|
||||||
|
if (state->whave < state->wsize)
|
||||||
|
state->whave = state->wsize - left;
|
||||||
|
inflate_fast(strm, state->wsize);
|
||||||
|
LOAD();
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* get a literal, length, or end-of-block code */
|
||||||
|
for (;;) {
|
||||||
|
here = state->lencode[BITS(state->lenbits)];
|
||||||
|
if ((unsigned)(here.bits) <= bits) break;
|
||||||
|
PULLBYTE();
|
||||||
|
}
|
||||||
|
if (here.op && (here.op & 0xf0) == 0) {
|
||||||
|
last = here;
|
||||||
|
for (;;) {
|
||||||
|
here = state->lencode[last.val +
|
||||||
|
(BITS(last.bits + last.op) >> last.bits)];
|
||||||
|
if ((unsigned)(last.bits + here.bits) <= bits) break;
|
||||||
|
PULLBYTE();
|
||||||
|
}
|
||||||
|
DROPBITS(last.bits);
|
||||||
|
}
|
||||||
|
DROPBITS(here.bits);
|
||||||
|
state->length = (unsigned)here.val;
|
||||||
|
|
||||||
|
/* process literal */
|
||||||
|
if (here.op == 0) {
|
||||||
|
Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
|
||||||
|
"inflate: literal '%c'\n" :
|
||||||
|
"inflate: literal 0x%02x\n", here.val));
|
||||||
|
ROOM();
|
||||||
|
*put++ = (unsigned char)(state->length);
|
||||||
|
left--;
|
||||||
|
state->mode = LEN;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* process end of block */
|
||||||
|
if (here.op & 32) {
|
||||||
|
Tracevv((stderr, "inflate: end of block\n"));
|
||||||
|
state->mode = TYPE;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* invalid code */
|
||||||
|
if (here.op & 64) {
|
||||||
|
strm->msg = (char *)"invalid literal/length code";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* length code -- get extra bits, if any */
|
||||||
|
state->extra = (unsigned)(here.op) & 15;
|
||||||
|
if (state->extra != 0) {
|
||||||
|
NEEDBITS(state->extra);
|
||||||
|
state->length += BITS(state->extra);
|
||||||
|
DROPBITS(state->extra);
|
||||||
|
}
|
||||||
|
Tracevv((stderr, "inflate: length %u\n", state->length));
|
||||||
|
|
||||||
|
/* get distance code */
|
||||||
|
for (;;) {
|
||||||
|
here = state->distcode[BITS(state->distbits)];
|
||||||
|
if ((unsigned)(here.bits) <= bits) break;
|
||||||
|
PULLBYTE();
|
||||||
|
}
|
||||||
|
if ((here.op & 0xf0) == 0) {
|
||||||
|
last = here;
|
||||||
|
for (;;) {
|
||||||
|
here = state->distcode[last.val +
|
||||||
|
(BITS(last.bits + last.op) >> last.bits)];
|
||||||
|
if ((unsigned)(last.bits + here.bits) <= bits) break;
|
||||||
|
PULLBYTE();
|
||||||
|
}
|
||||||
|
DROPBITS(last.bits);
|
||||||
|
}
|
||||||
|
DROPBITS(here.bits);
|
||||||
|
if (here.op & 64) {
|
||||||
|
strm->msg = (char *)"invalid distance code";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
state->offset = (unsigned)here.val;
|
||||||
|
|
||||||
|
/* get distance extra bits, if any */
|
||||||
|
state->extra = (unsigned)(here.op) & 15;
|
||||||
|
if (state->extra != 0) {
|
||||||
|
NEEDBITS(state->extra);
|
||||||
|
state->offset += BITS(state->extra);
|
||||||
|
DROPBITS(state->extra);
|
||||||
|
}
|
||||||
|
if (state->offset > state->wsize - (state->whave < state->wsize ?
|
||||||
|
left : 0)) {
|
||||||
|
strm->msg = (char *)"invalid distance too far back";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
Tracevv((stderr, "inflate: distance %u\n", state->offset));
|
||||||
|
|
||||||
|
/* copy match from window to output */
|
||||||
|
do {
|
||||||
|
ROOM();
|
||||||
|
copy = state->wsize - state->offset;
|
||||||
|
if (copy < left) {
|
||||||
|
from = put + copy;
|
||||||
|
copy = left - copy;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
from = put - state->offset;
|
||||||
|
copy = left;
|
||||||
|
}
|
||||||
|
if (copy > state->length) copy = state->length;
|
||||||
|
state->length -= copy;
|
||||||
|
left -= copy;
|
||||||
|
do {
|
||||||
|
*put++ = *from++;
|
||||||
|
} while (--copy);
|
||||||
|
} while (state->length != 0);
|
||||||
|
break;
|
||||||
|
|
||||||
|
case DONE:
|
||||||
|
/* inflate stream terminated properly -- write leftover output */
|
||||||
|
ret = Z_STREAM_END;
|
||||||
|
if (left < state->wsize) {
|
||||||
|
if (out(out_desc, state->window, state->wsize - left))
|
||||||
|
ret = Z_BUF_ERROR;
|
||||||
|
}
|
||||||
|
goto inf_leave;
|
||||||
|
|
||||||
|
case BAD:
|
||||||
|
ret = Z_DATA_ERROR;
|
||||||
|
goto inf_leave;
|
||||||
|
|
||||||
|
default: /* can't happen, but makes compilers happy */
|
||||||
|
ret = Z_STREAM_ERROR;
|
||||||
|
goto inf_leave;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Return unused input */
|
||||||
|
inf_leave:
|
||||||
|
strm->next_in = next;
|
||||||
|
strm->avail_in = have;
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int ZEXPORT inflateBackEnd(strm)
|
||||||
|
z_streamp strm;
|
||||||
|
{
|
||||||
|
if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
|
||||||
|
return Z_STREAM_ERROR;
|
||||||
|
ZFREE(strm, strm->state);
|
||||||
|
strm->state = Z_NULL;
|
||||||
|
Tracev((stderr, "inflate: end\n"));
|
||||||
|
return Z_OK;
|
||||||
|
}
|
323
libraries/zlib/inffast.c
Normal file
323
libraries/zlib/inffast.c
Normal file
@ -0,0 +1,323 @@
|
|||||||
|
/* inffast.c -- fast decoding
|
||||||
|
* Copyright (C) 1995-2017 Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "zutil.h"
|
||||||
|
#include "inftrees.h"
|
||||||
|
#include "inflate.h"
|
||||||
|
#include "inffast.h"
|
||||||
|
|
||||||
|
#ifdef ASMINF
|
||||||
|
# pragma message("Assembler code may have bugs -- use at your own risk")
|
||||||
|
#else
|
||||||
|
|
||||||
|
/*
|
||||||
|
Decode literal, length, and distance codes and write out the resulting
|
||||||
|
literal and match bytes until either not enough input or output is
|
||||||
|
available, an end-of-block is encountered, or a data error is encountered.
|
||||||
|
When large enough input and output buffers are supplied to inflate(), for
|
||||||
|
example, a 16K input buffer and a 64K output buffer, more than 95% of the
|
||||||
|
inflate execution time is spent in this routine.
|
||||||
|
|
||||||
|
Entry assumptions:
|
||||||
|
|
||||||
|
state->mode == LEN
|
||||||
|
strm->avail_in >= 6
|
||||||
|
strm->avail_out >= 258
|
||||||
|
start >= strm->avail_out
|
||||||
|
state->bits < 8
|
||||||
|
|
||||||
|
On return, state->mode is one of:
|
||||||
|
|
||||||
|
LEN -- ran out of enough output space or enough available input
|
||||||
|
TYPE -- reached end of block code, inflate() to interpret next block
|
||||||
|
BAD -- error in block data
|
||||||
|
|
||||||
|
Notes:
|
||||||
|
|
||||||
|
- The maximum input bits used by a length/distance pair is 15 bits for the
|
||||||
|
length code, 5 bits for the length extra, 15 bits for the distance code,
|
||||||
|
and 13 bits for the distance extra. This totals 48 bits, or six bytes.
|
||||||
|
Therefore if strm->avail_in >= 6, then there is enough input to avoid
|
||||||
|
checking for available input while decoding.
|
||||||
|
|
||||||
|
- The maximum bytes that a single length/distance pair can output is 258
|
||||||
|
bytes, which is the maximum length that can be coded. inflate_fast()
|
||||||
|
requires strm->avail_out >= 258 for each loop to avoid checking for
|
||||||
|
output space.
|
||||||
|
*/
|
||||||
|
void ZLIB_INTERNAL inflate_fast(strm, start)
|
||||||
|
z_streamp strm;
|
||||||
|
unsigned start; /* inflate()'s starting value for strm->avail_out */
|
||||||
|
{
|
||||||
|
struct inflate_state FAR *state;
|
||||||
|
z_const unsigned char FAR *in; /* local strm->next_in */
|
||||||
|
z_const unsigned char FAR *last; /* have enough input while in < last */
|
||||||
|
unsigned char FAR *out; /* local strm->next_out */
|
||||||
|
unsigned char FAR *beg; /* inflate()'s initial strm->next_out */
|
||||||
|
unsigned char FAR *end; /* while out < end, enough space available */
|
||||||
|
#ifdef INFLATE_STRICT
|
||||||
|
unsigned dmax; /* maximum distance from zlib header */
|
||||||
|
#endif
|
||||||
|
unsigned wsize; /* window size or zero if not using window */
|
||||||
|
unsigned whave; /* valid bytes in the window */
|
||||||
|
unsigned wnext; /* window write index */
|
||||||
|
unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */
|
||||||
|
unsigned long hold; /* local strm->hold */
|
||||||
|
unsigned bits; /* local strm->bits */
|
||||||
|
code const FAR *lcode; /* local strm->lencode */
|
||||||
|
code const FAR *dcode; /* local strm->distcode */
|
||||||
|
unsigned lmask; /* mask for first level of length codes */
|
||||||
|
unsigned dmask; /* mask for first level of distance codes */
|
||||||
|
code const *here; /* retrieved table entry */
|
||||||
|
unsigned op; /* code bits, operation, extra bits, or */
|
||||||
|
/* window position, window bytes to copy */
|
||||||
|
unsigned len; /* match length, unused bytes */
|
||||||
|
unsigned dist; /* match distance */
|
||||||
|
unsigned char FAR *from; /* where to copy match from */
|
||||||
|
|
||||||
|
/* copy state to local variables */
|
||||||
|
state = (struct inflate_state FAR *)strm->state;
|
||||||
|
in = strm->next_in;
|
||||||
|
last = in + (strm->avail_in - 5);
|
||||||
|
out = strm->next_out;
|
||||||
|
beg = out - (start - strm->avail_out);
|
||||||
|
end = out + (strm->avail_out - 257);
|
||||||
|
#ifdef INFLATE_STRICT
|
||||||
|
dmax = state->dmax;
|
||||||
|
#endif
|
||||||
|
wsize = state->wsize;
|
||||||
|
whave = state->whave;
|
||||||
|
wnext = state->wnext;
|
||||||
|
window = state->window;
|
||||||
|
hold = state->hold;
|
||||||
|
bits = state->bits;
|
||||||
|
lcode = state->lencode;
|
||||||
|
dcode = state->distcode;
|
||||||
|
lmask = (1U << state->lenbits) - 1;
|
||||||
|
dmask = (1U << state->distbits) - 1;
|
||||||
|
|
||||||
|
/* decode literals and length/distances until end-of-block or not enough
|
||||||
|
input data or output space */
|
||||||
|
do {
|
||||||
|
if (bits < 15) {
|
||||||
|
hold += (unsigned long)(*in++) << bits;
|
||||||
|
bits += 8;
|
||||||
|
hold += (unsigned long)(*in++) << bits;
|
||||||
|
bits += 8;
|
||||||
|
}
|
||||||
|
here = lcode + (hold & lmask);
|
||||||
|
dolen:
|
||||||
|
op = (unsigned)(here->bits);
|
||||||
|
hold >>= op;
|
||||||
|
bits -= op;
|
||||||
|
op = (unsigned)(here->op);
|
||||||
|
if (op == 0) { /* literal */
|
||||||
|
Tracevv((stderr, here->val >= 0x20 && here->val < 0x7f ?
|
||||||
|
"inflate: literal '%c'\n" :
|
||||||
|
"inflate: literal 0x%02x\n", here->val));
|
||||||
|
*out++ = (unsigned char)(here->val);
|
||||||
|
}
|
||||||
|
else if (op & 16) { /* length base */
|
||||||
|
len = (unsigned)(here->val);
|
||||||
|
op &= 15; /* number of extra bits */
|
||||||
|
if (op) {
|
||||||
|
if (bits < op) {
|
||||||
|
hold += (unsigned long)(*in++) << bits;
|
||||||
|
bits += 8;
|
||||||
|
}
|
||||||
|
len += (unsigned)hold & ((1U << op) - 1);
|
||||||
|
hold >>= op;
|
||||||
|
bits -= op;
|
||||||
|
}
|
||||||
|
Tracevv((stderr, "inflate: length %u\n", len));
|
||||||
|
if (bits < 15) {
|
||||||
|
hold += (unsigned long)(*in++) << bits;
|
||||||
|
bits += 8;
|
||||||
|
hold += (unsigned long)(*in++) << bits;
|
||||||
|
bits += 8;
|
||||||
|
}
|
||||||
|
here = dcode + (hold & dmask);
|
||||||
|
dodist:
|
||||||
|
op = (unsigned)(here->bits);
|
||||||
|
hold >>= op;
|
||||||
|
bits -= op;
|
||||||
|
op = (unsigned)(here->op);
|
||||||
|
if (op & 16) { /* distance base */
|
||||||
|
dist = (unsigned)(here->val);
|
||||||
|
op &= 15; /* number of extra bits */
|
||||||
|
if (bits < op) {
|
||||||
|
hold += (unsigned long)(*in++) << bits;
|
||||||
|
bits += 8;
|
||||||
|
if (bits < op) {
|
||||||
|
hold += (unsigned long)(*in++) << bits;
|
||||||
|
bits += 8;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
dist += (unsigned)hold & ((1U << op) - 1);
|
||||||
|
#ifdef INFLATE_STRICT
|
||||||
|
if (dist > dmax) {
|
||||||
|
strm->msg = (char *)"invalid distance too far back";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
hold >>= op;
|
||||||
|
bits -= op;
|
||||||
|
Tracevv((stderr, "inflate: distance %u\n", dist));
|
||||||
|
op = (unsigned)(out - beg); /* max distance in output */
|
||||||
|
if (dist > op) { /* see if copy from window */
|
||||||
|
op = dist - op; /* distance back in window */
|
||||||
|
if (op > whave) {
|
||||||
|
if (state->sane) {
|
||||||
|
strm->msg =
|
||||||
|
(char *)"invalid distance too far back";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
|
||||||
|
if (len <= op - whave) {
|
||||||
|
do {
|
||||||
|
*out++ = 0;
|
||||||
|
} while (--len);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
len -= op - whave;
|
||||||
|
do {
|
||||||
|
*out++ = 0;
|
||||||
|
} while (--op > whave);
|
||||||
|
if (op == 0) {
|
||||||
|
from = out - dist;
|
||||||
|
do {
|
||||||
|
*out++ = *from++;
|
||||||
|
} while (--len);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
from = window;
|
||||||
|
if (wnext == 0) { /* very common case */
|
||||||
|
from += wsize - op;
|
||||||
|
if (op < len) { /* some from window */
|
||||||
|
len -= op;
|
||||||
|
do {
|
||||||
|
*out++ = *from++;
|
||||||
|
} while (--op);
|
||||||
|
from = out - dist; /* rest from output */
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (wnext < op) { /* wrap around window */
|
||||||
|
from += wsize + wnext - op;
|
||||||
|
op -= wnext;
|
||||||
|
if (op < len) { /* some from end of window */
|
||||||
|
len -= op;
|
||||||
|
do {
|
||||||
|
*out++ = *from++;
|
||||||
|
} while (--op);
|
||||||
|
from = window;
|
||||||
|
if (wnext < len) { /* some from start of window */
|
||||||
|
op = wnext;
|
||||||
|
len -= op;
|
||||||
|
do {
|
||||||
|
*out++ = *from++;
|
||||||
|
} while (--op);
|
||||||
|
from = out - dist; /* rest from output */
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else { /* contiguous in window */
|
||||||
|
from += wnext - op;
|
||||||
|
if (op < len) { /* some from window */
|
||||||
|
len -= op;
|
||||||
|
do {
|
||||||
|
*out++ = *from++;
|
||||||
|
} while (--op);
|
||||||
|
from = out - dist; /* rest from output */
|
||||||
|
}
|
||||||
|
}
|
||||||
|
while (len > 2) {
|
||||||
|
*out++ = *from++;
|
||||||
|
*out++ = *from++;
|
||||||
|
*out++ = *from++;
|
||||||
|
len -= 3;
|
||||||
|
}
|
||||||
|
if (len) {
|
||||||
|
*out++ = *from++;
|
||||||
|
if (len > 1)
|
||||||
|
*out++ = *from++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
from = out - dist; /* copy direct from output */
|
||||||
|
do { /* minimum length is three */
|
||||||
|
*out++ = *from++;
|
||||||
|
*out++ = *from++;
|
||||||
|
*out++ = *from++;
|
||||||
|
len -= 3;
|
||||||
|
} while (len > 2);
|
||||||
|
if (len) {
|
||||||
|
*out++ = *from++;
|
||||||
|
if (len > 1)
|
||||||
|
*out++ = *from++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if ((op & 64) == 0) { /* 2nd level distance code */
|
||||||
|
here = dcode + here->val + (hold & ((1U << op) - 1));
|
||||||
|
goto dodist;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
strm->msg = (char *)"invalid distance code";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if ((op & 64) == 0) { /* 2nd level length code */
|
||||||
|
here = lcode + here->val + (hold & ((1U << op) - 1));
|
||||||
|
goto dolen;
|
||||||
|
}
|
||||||
|
else if (op & 32) { /* end-of-block */
|
||||||
|
Tracevv((stderr, "inflate: end of block\n"));
|
||||||
|
state->mode = TYPE;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
strm->msg = (char *)"invalid literal/length code";
|
||||||
|
state->mode = BAD;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
} while (in < last && out < end);
|
||||||
|
|
||||||
|
/* return unused bytes (on entry, bits < 8, so in won't go too far back) */
|
||||||
|
len = bits >> 3;
|
||||||
|
in -= len;
|
||||||
|
bits -= len << 3;
|
||||||
|
hold &= (1U << bits) - 1;
|
||||||
|
|
||||||
|
/* update state and return */
|
||||||
|
strm->next_in = in;
|
||||||
|
strm->next_out = out;
|
||||||
|
strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
|
||||||
|
strm->avail_out = (unsigned)(out < end ?
|
||||||
|
257 + (end - out) : 257 - (out - end));
|
||||||
|
state->hold = hold;
|
||||||
|
state->bits = bits;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):
|
||||||
|
- Using bit fields for code structure
|
||||||
|
- Different op definition to avoid & for extra bits (do & for table bits)
|
||||||
|
- Three separate decoding do-loops for direct, window, and wnext == 0
|
||||||
|
- Special case for distance > 1 copies to do overlapped load and store copy
|
||||||
|
- Explicit branch predictions (based on measured branch probabilities)
|
||||||
|
- Deferring match copy and interspersed it with decoding subsequent codes
|
||||||
|
- Swapping literal/length else
|
||||||
|
- Swapping window/direct else
|
||||||
|
- Larger unrolled copy loops (three is about right)
|
||||||
|
- Moving len -= 3 statement into middle of loop
|
||||||
|
*/
|
||||||
|
|
||||||
|
#endif /* !ASMINF */
|
11
libraries/zlib/inffast.h
Normal file
11
libraries/zlib/inffast.h
Normal file
@ -0,0 +1,11 @@
|
|||||||
|
/* inffast.h -- header to use inffast.c
|
||||||
|
* Copyright (C) 1995-2003, 2010 Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* WARNING: this file should *not* be used by applications. It is
|
||||||
|
part of the implementation of the compression library and is
|
||||||
|
subject to change. Applications should only use zlib.h.
|
||||||
|
*/
|
||||||
|
|
||||||
|
void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start));
|
94
libraries/zlib/inffixed.h
Normal file
94
libraries/zlib/inffixed.h
Normal file
@ -0,0 +1,94 @@
|
|||||||
|
/* inffixed.h -- table for decoding fixed codes
|
||||||
|
* Generated automatically by makefixed().
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* WARNING: this file should *not* be used by applications.
|
||||||
|
It is part of the implementation of this library and is
|
||||||
|
subject to change. Applications should only use zlib.h.
|
||||||
|
*/
|
||||||
|
|
||||||
|
static const code lenfix[512] = {
|
||||||
|
{96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
|
||||||
|
{0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
|
||||||
|
{0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
|
||||||
|
{0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
|
||||||
|
{0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
|
||||||
|
{21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
|
||||||
|
{0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
|
||||||
|
{0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
|
||||||
|
{18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
|
||||||
|
{0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
|
||||||
|
{0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
|
||||||
|
{0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
|
||||||
|
{20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
|
||||||
|
{0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
|
||||||
|
{0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
|
||||||
|
{0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
|
||||||
|
{16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
|
||||||
|
{0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
|
||||||
|
{0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
|
||||||
|
{0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
|
||||||
|
{0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
|
||||||
|
{0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
|
||||||
|
{0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
|
||||||
|
{0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
|
||||||
|
{17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
|
||||||
|
{0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
|
||||||
|
{0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
|
||||||
|
{0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
|
||||||
|
{19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
|
||||||
|
{0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
|
||||||
|
{0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
|
||||||
|
{0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
|
||||||
|
{16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
|
||||||
|
{0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
|
||||||
|
{0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
|
||||||
|
{0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
|
||||||
|
{0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
|
||||||
|
{20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
|
||||||
|
{0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
|
||||||
|
{0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
|
||||||
|
{17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
|
||||||
|
{0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
|
||||||
|
{0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
|
||||||
|
{0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
|
||||||
|
{20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
|
||||||
|
{0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
|
||||||
|
{0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
|
||||||
|
{0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
|
||||||
|
{16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
|
||||||
|
{0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
|
||||||
|
{0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
|
||||||
|
{0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
|
||||||
|
{0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
|
||||||
|
{0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
|
||||||
|
{0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
|
||||||
|
{0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
|
||||||
|
{16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
|
||||||
|
{0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
|
||||||
|
{0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
|
||||||
|
{0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
|
||||||
|
{19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
|
||||||
|
{0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
|
||||||
|
{0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
|
||||||
|
{0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
|
||||||
|
{16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
|
||||||
|
{0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
|
||||||
|
{0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
|
||||||
|
{0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
|
||||||
|
{0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
|
||||||
|
{64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
|
||||||
|
{0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
|
||||||
|
{0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
|
||||||
|
{18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
|
||||||
|
{0,9,255}
|
||||||
|
};
|
||||||
|
|
||||||
|
static const code distfix[32] = {
|
||||||
|
{16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
|
||||||
|
{21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
|
||||||
|
{18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
|
||||||
|
{19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
|
||||||
|
{16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
|
||||||
|
{22,5,193},{64,5,0}
|
||||||
|
};
|
1592
libraries/zlib/inflate.c
Normal file
1592
libraries/zlib/inflate.c
Normal file
File diff suppressed because it is too large
Load Diff
126
libraries/zlib/inflate.h
Normal file
126
libraries/zlib/inflate.h
Normal file
@ -0,0 +1,126 @@
|
|||||||
|
/* inflate.h -- internal inflate state definition
|
||||||
|
* Copyright (C) 1995-2019 Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* WARNING: this file should *not* be used by applications. It is
|
||||||
|
part of the implementation of the compression library and is
|
||||||
|
subject to change. Applications should only use zlib.h.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* define NO_GZIP when compiling if you want to disable gzip header and
|
||||||
|
trailer decoding by inflate(). NO_GZIP would be used to avoid linking in
|
||||||
|
the crc code when it is not needed. For shared libraries, gzip decoding
|
||||||
|
should be left enabled. */
|
||||||
|
#ifndef NO_GZIP
|
||||||
|
# define GUNZIP
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* Possible inflate modes between inflate() calls */
|
||||||
|
typedef enum {
|
||||||
|
HEAD = 16180, /* i: waiting for magic header */
|
||||||
|
FLAGS, /* i: waiting for method and flags (gzip) */
|
||||||
|
TIME, /* i: waiting for modification time (gzip) */
|
||||||
|
OS, /* i: waiting for extra flags and operating system (gzip) */
|
||||||
|
EXLEN, /* i: waiting for extra length (gzip) */
|
||||||
|
EXTRA, /* i: waiting for extra bytes (gzip) */
|
||||||
|
NAME, /* i: waiting for end of file name (gzip) */
|
||||||
|
COMMENT, /* i: waiting for end of comment (gzip) */
|
||||||
|
HCRC, /* i: waiting for header crc (gzip) */
|
||||||
|
DICTID, /* i: waiting for dictionary check value */
|
||||||
|
DICT, /* waiting for inflateSetDictionary() call */
|
||||||
|
TYPE, /* i: waiting for type bits, including last-flag bit */
|
||||||
|
TYPEDO, /* i: same, but skip check to exit inflate on new block */
|
||||||
|
STORED, /* i: waiting for stored size (length and complement) */
|
||||||
|
COPY_, /* i/o: same as COPY below, but only first time in */
|
||||||
|
COPY, /* i/o: waiting for input or output to copy stored block */
|
||||||
|
TABLE, /* i: waiting for dynamic block table lengths */
|
||||||
|
LENLENS, /* i: waiting for code length code lengths */
|
||||||
|
CODELENS, /* i: waiting for length/lit and distance code lengths */
|
||||||
|
LEN_, /* i: same as LEN below, but only first time in */
|
||||||
|
LEN, /* i: waiting for length/lit/eob code */
|
||||||
|
LENEXT, /* i: waiting for length extra bits */
|
||||||
|
DIST, /* i: waiting for distance code */
|
||||||
|
DISTEXT, /* i: waiting for distance extra bits */
|
||||||
|
MATCH, /* o: waiting for output space to copy string */
|
||||||
|
LIT, /* o: waiting for output space to write literal */
|
||||||
|
CHECK, /* i: waiting for 32-bit check value */
|
||||||
|
LENGTH, /* i: waiting for 32-bit length (gzip) */
|
||||||
|
DONE, /* finished check, done -- remain here until reset */
|
||||||
|
BAD, /* got a data error -- remain here until reset */
|
||||||
|
MEM, /* got an inflate() memory error -- remain here until reset */
|
||||||
|
SYNC /* looking for synchronization bytes to restart inflate() */
|
||||||
|
} inflate_mode;
|
||||||
|
|
||||||
|
/*
|
||||||
|
State transitions between above modes -
|
||||||
|
|
||||||
|
(most modes can go to BAD or MEM on error -- not shown for clarity)
|
||||||
|
|
||||||
|
Process header:
|
||||||
|
HEAD -> (gzip) or (zlib) or (raw)
|
||||||
|
(gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT ->
|
||||||
|
HCRC -> TYPE
|
||||||
|
(zlib) -> DICTID or TYPE
|
||||||
|
DICTID -> DICT -> TYPE
|
||||||
|
(raw) -> TYPEDO
|
||||||
|
Read deflate blocks:
|
||||||
|
TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK
|
||||||
|
STORED -> COPY_ -> COPY -> TYPE
|
||||||
|
TABLE -> LENLENS -> CODELENS -> LEN_
|
||||||
|
LEN_ -> LEN
|
||||||
|
Read deflate codes in fixed or dynamic block:
|
||||||
|
LEN -> LENEXT or LIT or TYPE
|
||||||
|
LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
|
||||||
|
LIT -> LEN
|
||||||
|
Process trailer:
|
||||||
|
CHECK -> LENGTH -> DONE
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* State maintained between inflate() calls -- approximately 7K bytes, not
|
||||||
|
including the allocated sliding window, which is up to 32K bytes. */
|
||||||
|
struct inflate_state {
|
||||||
|
z_streamp strm; /* pointer back to this zlib stream */
|
||||||
|
inflate_mode mode; /* current inflate mode */
|
||||||
|
int last; /* true if processing last block */
|
||||||
|
int wrap; /* bit 0 true for zlib, bit 1 true for gzip,
|
||||||
|
bit 2 true to validate check value */
|
||||||
|
int havedict; /* true if dictionary provided */
|
||||||
|
int flags; /* gzip header method and flags, 0 if zlib, or
|
||||||
|
-1 if raw or no header yet */
|
||||||
|
unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */
|
||||||
|
unsigned long check; /* protected copy of check value */
|
||||||
|
unsigned long total; /* protected copy of output count */
|
||||||
|
gz_headerp head; /* where to save gzip header information */
|
||||||
|
/* sliding window */
|
||||||
|
unsigned wbits; /* log base 2 of requested window size */
|
||||||
|
unsigned wsize; /* window size or zero if not using window */
|
||||||
|
unsigned whave; /* valid bytes in the window */
|
||||||
|
unsigned wnext; /* window write index */
|
||||||
|
unsigned char FAR *window; /* allocated sliding window, if needed */
|
||||||
|
/* bit accumulator */
|
||||||
|
unsigned long hold; /* input bit accumulator */
|
||||||
|
unsigned bits; /* number of bits in "in" */
|
||||||
|
/* for string and stored block copying */
|
||||||
|
unsigned length; /* literal or length of data to copy */
|
||||||
|
unsigned offset; /* distance back to copy string from */
|
||||||
|
/* for table and code decoding */
|
||||||
|
unsigned extra; /* extra bits needed */
|
||||||
|
/* fixed and dynamic code tables */
|
||||||
|
code const FAR *lencode; /* starting table for length/literal codes */
|
||||||
|
code const FAR *distcode; /* starting table for distance codes */
|
||||||
|
unsigned lenbits; /* index bits for lencode */
|
||||||
|
unsigned distbits; /* index bits for distcode */
|
||||||
|
/* dynamic table building */
|
||||||
|
unsigned ncode; /* number of code length code lengths */
|
||||||
|
unsigned nlen; /* number of length code lengths */
|
||||||
|
unsigned ndist; /* number of distance code lengths */
|
||||||
|
unsigned have; /* number of code lengths in lens[] */
|
||||||
|
code FAR *next; /* next available space in codes[] */
|
||||||
|
unsigned short lens[320]; /* temporary storage for code lengths */
|
||||||
|
unsigned short work[288]; /* work area for code table building */
|
||||||
|
code codes[ENOUGH]; /* space for code tables */
|
||||||
|
int sane; /* if false, allow invalid distance too far */
|
||||||
|
int back; /* bits back of last unprocessed length/lit */
|
||||||
|
unsigned was; /* initial length of match */
|
||||||
|
};
|
304
libraries/zlib/inftrees.c
Normal file
304
libraries/zlib/inftrees.c
Normal file
@ -0,0 +1,304 @@
|
|||||||
|
/* inftrees.c -- generate Huffman trees for efficient decoding
|
||||||
|
* Copyright (C) 1995-2022 Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "zutil.h"
|
||||||
|
#include "inftrees.h"
|
||||||
|
|
||||||
|
#define MAXBITS 15
|
||||||
|
|
||||||
|
const char inflate_copyright[] =
|
||||||
|
" inflate 1.2.12 Copyright 1995-2022 Mark Adler ";
|
||||||
|
/*
|
||||||
|
If you use the zlib library in a product, an acknowledgment is welcome
|
||||||
|
in the documentation of your product. If for some reason you cannot
|
||||||
|
include such an acknowledgment, I would appreciate that you keep this
|
||||||
|
copyright string in the executable of your product.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
Build a set of tables to decode the provided canonical Huffman code.
|
||||||
|
The code lengths are lens[0..codes-1]. The result starts at *table,
|
||||||
|
whose indices are 0..2^bits-1. work is a writable array of at least
|
||||||
|
lens shorts, which is used as a work area. type is the type of code
|
||||||
|
to be generated, CODES, LENS, or DISTS. On return, zero is success,
|
||||||
|
-1 is an invalid code, and +1 means that ENOUGH isn't enough. table
|
||||||
|
on return points to the next available entry's address. bits is the
|
||||||
|
requested root table index bits, and on return it is the actual root
|
||||||
|
table index bits. It will differ if the request is greater than the
|
||||||
|
longest code or if it is less than the shortest code.
|
||||||
|
*/
|
||||||
|
int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work)
|
||||||
|
codetype type;
|
||||||
|
unsigned short FAR *lens;
|
||||||
|
unsigned codes;
|
||||||
|
code FAR * FAR *table;
|
||||||
|
unsigned FAR *bits;
|
||||||
|
unsigned short FAR *work;
|
||||||
|
{
|
||||||
|
unsigned len; /* a code's length in bits */
|
||||||
|
unsigned sym; /* index of code symbols */
|
||||||
|
unsigned min, max; /* minimum and maximum code lengths */
|
||||||
|
unsigned root; /* number of index bits for root table */
|
||||||
|
unsigned curr; /* number of index bits for current table */
|
||||||
|
unsigned drop; /* code bits to drop for sub-table */
|
||||||
|
int left; /* number of prefix codes available */
|
||||||
|
unsigned used; /* code entries in table used */
|
||||||
|
unsigned huff; /* Huffman code */
|
||||||
|
unsigned incr; /* for incrementing code, index */
|
||||||
|
unsigned fill; /* index for replicating entries */
|
||||||
|
unsigned low; /* low bits for current root entry */
|
||||||
|
unsigned mask; /* mask for low root bits */
|
||||||
|
code here; /* table entry for duplication */
|
||||||
|
code FAR *next; /* next available space in table */
|
||||||
|
const unsigned short FAR *base; /* base value table to use */
|
||||||
|
const unsigned short FAR *extra; /* extra bits table to use */
|
||||||
|
unsigned match; /* use base and extra for symbol >= match */
|
||||||
|
unsigned short count[MAXBITS+1]; /* number of codes of each length */
|
||||||
|
unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
|
||||||
|
static const unsigned short lbase[31] = { /* Length codes 257..285 base */
|
||||||
|
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
|
||||||
|
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
|
||||||
|
static const unsigned short lext[31] = { /* Length codes 257..285 extra */
|
||||||
|
16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
|
||||||
|
19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 199, 202};
|
||||||
|
static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
|
||||||
|
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
|
||||||
|
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
|
||||||
|
8193, 12289, 16385, 24577, 0, 0};
|
||||||
|
static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
|
||||||
|
16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
|
||||||
|
23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
|
||||||
|
28, 28, 29, 29, 64, 64};
|
||||||
|
|
||||||
|
/*
|
||||||
|
Process a set of code lengths to create a canonical Huffman code. The
|
||||||
|
code lengths are lens[0..codes-1]. Each length corresponds to the
|
||||||
|
symbols 0..codes-1. The Huffman code is generated by first sorting the
|
||||||
|
symbols by length from short to long, and retaining the symbol order
|
||||||
|
for codes with equal lengths. Then the code starts with all zero bits
|
||||||
|
for the first code of the shortest length, and the codes are integer
|
||||||
|
increments for the same length, and zeros are appended as the length
|
||||||
|
increases. For the deflate format, these bits are stored backwards
|
||||||
|
from their more natural integer increment ordering, and so when the
|
||||||
|
decoding tables are built in the large loop below, the integer codes
|
||||||
|
are incremented backwards.
|
||||||
|
|
||||||
|
This routine assumes, but does not check, that all of the entries in
|
||||||
|
lens[] are in the range 0..MAXBITS. The caller must assure this.
|
||||||
|
1..MAXBITS is interpreted as that code length. zero means that that
|
||||||
|
symbol does not occur in this code.
|
||||||
|
|
||||||
|
The codes are sorted by computing a count of codes for each length,
|
||||||
|
creating from that a table of starting indices for each length in the
|
||||||
|
sorted table, and then entering the symbols in order in the sorted
|
||||||
|
table. The sorted table is work[], with that space being provided by
|
||||||
|
the caller.
|
||||||
|
|
||||||
|
The length counts are used for other purposes as well, i.e. finding
|
||||||
|
the minimum and maximum length codes, determining if there are any
|
||||||
|
codes at all, checking for a valid set of lengths, and looking ahead
|
||||||
|
at length counts to determine sub-table sizes when building the
|
||||||
|
decoding tables.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
|
||||||
|
for (len = 0; len <= MAXBITS; len++)
|
||||||
|
count[len] = 0;
|
||||||
|
for (sym = 0; sym < codes; sym++)
|
||||||
|
count[lens[sym]]++;
|
||||||
|
|
||||||
|
/* bound code lengths, force root to be within code lengths */
|
||||||
|
root = *bits;
|
||||||
|
for (max = MAXBITS; max >= 1; max--)
|
||||||
|
if (count[max] != 0) break;
|
||||||
|
if (root > max) root = max;
|
||||||
|
if (max == 0) { /* no symbols to code at all */
|
||||||
|
here.op = (unsigned char)64; /* invalid code marker */
|
||||||
|
here.bits = (unsigned char)1;
|
||||||
|
here.val = (unsigned short)0;
|
||||||
|
*(*table)++ = here; /* make a table to force an error */
|
||||||
|
*(*table)++ = here;
|
||||||
|
*bits = 1;
|
||||||
|
return 0; /* no symbols, but wait for decoding to report error */
|
||||||
|
}
|
||||||
|
for (min = 1; min < max; min++)
|
||||||
|
if (count[min] != 0) break;
|
||||||
|
if (root < min) root = min;
|
||||||
|
|
||||||
|
/* check for an over-subscribed or incomplete set of lengths */
|
||||||
|
left = 1;
|
||||||
|
for (len = 1; len <= MAXBITS; len++) {
|
||||||
|
left <<= 1;
|
||||||
|
left -= count[len];
|
||||||
|
if (left < 0) return -1; /* over-subscribed */
|
||||||
|
}
|
||||||
|
if (left > 0 && (type == CODES || max != 1))
|
||||||
|
return -1; /* incomplete set */
|
||||||
|
|
||||||
|
/* generate offsets into symbol table for each length for sorting */
|
||||||
|
offs[1] = 0;
|
||||||
|
for (len = 1; len < MAXBITS; len++)
|
||||||
|
offs[len + 1] = offs[len] + count[len];
|
||||||
|
|
||||||
|
/* sort symbols by length, by symbol order within each length */
|
||||||
|
for (sym = 0; sym < codes; sym++)
|
||||||
|
if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
|
||||||
|
|
||||||
|
/*
|
||||||
|
Create and fill in decoding tables. In this loop, the table being
|
||||||
|
filled is at next and has curr index bits. The code being used is huff
|
||||||
|
with length len. That code is converted to an index by dropping drop
|
||||||
|
bits off of the bottom. For codes where len is less than drop + curr,
|
||||||
|
those top drop + curr - len bits are incremented through all values to
|
||||||
|
fill the table with replicated entries.
|
||||||
|
|
||||||
|
root is the number of index bits for the root table. When len exceeds
|
||||||
|
root, sub-tables are created pointed to by the root entry with an index
|
||||||
|
of the low root bits of huff. This is saved in low to check for when a
|
||||||
|
new sub-table should be started. drop is zero when the root table is
|
||||||
|
being filled, and drop is root when sub-tables are being filled.
|
||||||
|
|
||||||
|
When a new sub-table is needed, it is necessary to look ahead in the
|
||||||
|
code lengths to determine what size sub-table is needed. The length
|
||||||
|
counts are used for this, and so count[] is decremented as codes are
|
||||||
|
entered in the tables.
|
||||||
|
|
||||||
|
used keeps track of how many table entries have been allocated from the
|
||||||
|
provided *table space. It is checked for LENS and DIST tables against
|
||||||
|
the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
|
||||||
|
the initial root table size constants. See the comments in inftrees.h
|
||||||
|
for more information.
|
||||||
|
|
||||||
|
sym increments through all symbols, and the loop terminates when
|
||||||
|
all codes of length max, i.e. all codes, have been processed. This
|
||||||
|
routine permits incomplete codes, so another loop after this one fills
|
||||||
|
in the rest of the decoding tables with invalid code markers.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* set up for code type */
|
||||||
|
switch (type) {
|
||||||
|
case CODES:
|
||||||
|
base = extra = work; /* dummy value--not used */
|
||||||
|
match = 20;
|
||||||
|
break;
|
||||||
|
case LENS:
|
||||||
|
base = lbase;
|
||||||
|
extra = lext;
|
||||||
|
match = 257;
|
||||||
|
break;
|
||||||
|
default: /* DISTS */
|
||||||
|
base = dbase;
|
||||||
|
extra = dext;
|
||||||
|
match = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* initialize state for loop */
|
||||||
|
huff = 0; /* starting code */
|
||||||
|
sym = 0; /* starting code symbol */
|
||||||
|
len = min; /* starting code length */
|
||||||
|
next = *table; /* current table to fill in */
|
||||||
|
curr = root; /* current table index bits */
|
||||||
|
drop = 0; /* current bits to drop from code for index */
|
||||||
|
low = (unsigned)(-1); /* trigger new sub-table when len > root */
|
||||||
|
used = 1U << root; /* use root table entries */
|
||||||
|
mask = used - 1; /* mask for comparing low */
|
||||||
|
|
||||||
|
/* check available table space */
|
||||||
|
if ((type == LENS && used > ENOUGH_LENS) ||
|
||||||
|
(type == DISTS && used > ENOUGH_DISTS))
|
||||||
|
return 1;
|
||||||
|
|
||||||
|
/* process all codes and make table entries */
|
||||||
|
for (;;) {
|
||||||
|
/* create table entry */
|
||||||
|
here.bits = (unsigned char)(len - drop);
|
||||||
|
if (work[sym] + 1U < match) {
|
||||||
|
here.op = (unsigned char)0;
|
||||||
|
here.val = work[sym];
|
||||||
|
}
|
||||||
|
else if (work[sym] >= match) {
|
||||||
|
here.op = (unsigned char)(extra[work[sym] - match]);
|
||||||
|
here.val = base[work[sym] - match];
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
here.op = (unsigned char)(32 + 64); /* end of block */
|
||||||
|
here.val = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* replicate for those indices with low len bits equal to huff */
|
||||||
|
incr = 1U << (len - drop);
|
||||||
|
fill = 1U << curr;
|
||||||
|
min = fill; /* save offset to next table */
|
||||||
|
do {
|
||||||
|
fill -= incr;
|
||||||
|
next[(huff >> drop) + fill] = here;
|
||||||
|
} while (fill != 0);
|
||||||
|
|
||||||
|
/* backwards increment the len-bit code huff */
|
||||||
|
incr = 1U << (len - 1);
|
||||||
|
while (huff & incr)
|
||||||
|
incr >>= 1;
|
||||||
|
if (incr != 0) {
|
||||||
|
huff &= incr - 1;
|
||||||
|
huff += incr;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
huff = 0;
|
||||||
|
|
||||||
|
/* go to next symbol, update count, len */
|
||||||
|
sym++;
|
||||||
|
if (--(count[len]) == 0) {
|
||||||
|
if (len == max) break;
|
||||||
|
len = lens[work[sym]];
|
||||||
|
}
|
||||||
|
|
||||||
|
/* create new sub-table if needed */
|
||||||
|
if (len > root && (huff & mask) != low) {
|
||||||
|
/* if first time, transition to sub-tables */
|
||||||
|
if (drop == 0)
|
||||||
|
drop = root;
|
||||||
|
|
||||||
|
/* increment past last table */
|
||||||
|
next += min; /* here min is 1 << curr */
|
||||||
|
|
||||||
|
/* determine length of next table */
|
||||||
|
curr = len - drop;
|
||||||
|
left = (int)(1 << curr);
|
||||||
|
while (curr + drop < max) {
|
||||||
|
left -= count[curr + drop];
|
||||||
|
if (left <= 0) break;
|
||||||
|
curr++;
|
||||||
|
left <<= 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* check for enough space */
|
||||||
|
used += 1U << curr;
|
||||||
|
if ((type == LENS && used > ENOUGH_LENS) ||
|
||||||
|
(type == DISTS && used > ENOUGH_DISTS))
|
||||||
|
return 1;
|
||||||
|
|
||||||
|
/* point entry in root table to sub-table */
|
||||||
|
low = huff & mask;
|
||||||
|
(*table)[low].op = (unsigned char)curr;
|
||||||
|
(*table)[low].bits = (unsigned char)root;
|
||||||
|
(*table)[low].val = (unsigned short)(next - *table);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* fill in remaining table entry if code is incomplete (guaranteed to have
|
||||||
|
at most one remaining entry, since if the code is incomplete, the
|
||||||
|
maximum code length that was allowed to get this far is one bit) */
|
||||||
|
if (huff != 0) {
|
||||||
|
here.op = (unsigned char)64; /* invalid code marker */
|
||||||
|
here.bits = (unsigned char)(len - drop);
|
||||||
|
here.val = (unsigned short)0;
|
||||||
|
next[huff] = here;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* set return parameters */
|
||||||
|
*table += used;
|
||||||
|
*bits = root;
|
||||||
|
return 0;
|
||||||
|
}
|
62
libraries/zlib/inftrees.h
Normal file
62
libraries/zlib/inftrees.h
Normal file
@ -0,0 +1,62 @@
|
|||||||
|
/* inftrees.h -- header to use inftrees.c
|
||||||
|
* Copyright (C) 1995-2005, 2010 Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* WARNING: this file should *not* be used by applications. It is
|
||||||
|
part of the implementation of the compression library and is
|
||||||
|
subject to change. Applications should only use zlib.h.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* Structure for decoding tables. Each entry provides either the
|
||||||
|
information needed to do the operation requested by the code that
|
||||||
|
indexed that table entry, or it provides a pointer to another
|
||||||
|
table that indexes more bits of the code. op indicates whether
|
||||||
|
the entry is a pointer to another table, a literal, a length or
|
||||||
|
distance, an end-of-block, or an invalid code. For a table
|
||||||
|
pointer, the low four bits of op is the number of index bits of
|
||||||
|
that table. For a length or distance, the low four bits of op
|
||||||
|
is the number of extra bits to get after the code. bits is
|
||||||
|
the number of bits in this code or part of the code to drop off
|
||||||
|
of the bit buffer. val is the actual byte to output in the case
|
||||||
|
of a literal, the base length or distance, or the offset from
|
||||||
|
the current table to the next table. Each entry is four bytes. */
|
||||||
|
typedef struct {
|
||||||
|
unsigned char op; /* operation, extra bits, table bits */
|
||||||
|
unsigned char bits; /* bits in this part of the code */
|
||||||
|
unsigned short val; /* offset in table or code value */
|
||||||
|
} code;
|
||||||
|
|
||||||
|
/* op values as set by inflate_table():
|
||||||
|
00000000 - literal
|
||||||
|
0000tttt - table link, tttt != 0 is the number of table index bits
|
||||||
|
0001eeee - length or distance, eeee is the number of extra bits
|
||||||
|
01100000 - end of block
|
||||||
|
01000000 - invalid code
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* Maximum size of the dynamic table. The maximum number of code structures is
|
||||||
|
1444, which is the sum of 852 for literal/length codes and 592 for distance
|
||||||
|
codes. These values were found by exhaustive searches using the program
|
||||||
|
examples/enough.c found in the zlib distribtution. The arguments to that
|
||||||
|
program are the number of symbols, the initial root table size, and the
|
||||||
|
maximum bit length of a code. "enough 286 9 15" for literal/length codes
|
||||||
|
returns returns 852, and "enough 30 6 15" for distance codes returns 592.
|
||||||
|
The initial root table size (9 or 6) is found in the fifth argument of the
|
||||||
|
inflate_table() calls in inflate.c and infback.c. If the root table size is
|
||||||
|
changed, then these maximum sizes would be need to be recalculated and
|
||||||
|
updated. */
|
||||||
|
#define ENOUGH_LENS 852
|
||||||
|
#define ENOUGH_DISTS 592
|
||||||
|
#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS)
|
||||||
|
|
||||||
|
/* Type of code to build for inflate_table() */
|
||||||
|
typedef enum {
|
||||||
|
CODES,
|
||||||
|
LENS,
|
||||||
|
DISTS
|
||||||
|
} codetype;
|
||||||
|
|
||||||
|
int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens,
|
||||||
|
unsigned codes, code FAR * FAR *table,
|
||||||
|
unsigned FAR *bits, unsigned short FAR *work));
|
1182
libraries/zlib/trees.c
Normal file
1182
libraries/zlib/trees.c
Normal file
File diff suppressed because it is too large
Load Diff
128
libraries/zlib/trees.h
Normal file
128
libraries/zlib/trees.h
Normal file
@ -0,0 +1,128 @@
|
|||||||
|
/* header created automatically with -DGEN_TREES_H */
|
||||||
|
|
||||||
|
local const ct_data static_ltree[L_CODES+2] = {
|
||||||
|
{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}},
|
||||||
|
{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}},
|
||||||
|
{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}},
|
||||||
|
{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}},
|
||||||
|
{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}},
|
||||||
|
{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}},
|
||||||
|
{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}},
|
||||||
|
{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}},
|
||||||
|
{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}},
|
||||||
|
{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}},
|
||||||
|
{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}},
|
||||||
|
{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}},
|
||||||
|
{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}},
|
||||||
|
{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}},
|
||||||
|
{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}},
|
||||||
|
{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}},
|
||||||
|
{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}},
|
||||||
|
{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}},
|
||||||
|
{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}},
|
||||||
|
{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}},
|
||||||
|
{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}},
|
||||||
|
{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}},
|
||||||
|
{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}},
|
||||||
|
{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}},
|
||||||
|
{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}},
|
||||||
|
{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}},
|
||||||
|
{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}},
|
||||||
|
{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}},
|
||||||
|
{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}},
|
||||||
|
{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}},
|
||||||
|
{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}},
|
||||||
|
{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}},
|
||||||
|
{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}},
|
||||||
|
{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}},
|
||||||
|
{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}},
|
||||||
|
{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}},
|
||||||
|
{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}},
|
||||||
|
{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}},
|
||||||
|
{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}},
|
||||||
|
{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}},
|
||||||
|
{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}},
|
||||||
|
{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}},
|
||||||
|
{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}},
|
||||||
|
{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}},
|
||||||
|
{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}},
|
||||||
|
{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}},
|
||||||
|
{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}},
|
||||||
|
{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}},
|
||||||
|
{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}},
|
||||||
|
{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}},
|
||||||
|
{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}},
|
||||||
|
{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}},
|
||||||
|
{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}},
|
||||||
|
{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}},
|
||||||
|
{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}},
|
||||||
|
{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}},
|
||||||
|
{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}},
|
||||||
|
{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}}
|
||||||
|
};
|
||||||
|
|
||||||
|
local const ct_data static_dtree[D_CODES] = {
|
||||||
|
{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
|
||||||
|
{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
|
||||||
|
{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
|
||||||
|
{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
|
||||||
|
{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
|
||||||
|
{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
|
||||||
|
};
|
||||||
|
|
||||||
|
const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {
|
||||||
|
0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8,
|
||||||
|
8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10,
|
||||||
|
10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
|
||||||
|
11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
|
||||||
|
12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
|
||||||
|
13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||||
|
13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||||
|
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||||
|
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||||
|
14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
|
||||||
|
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
|
||||||
|
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
|
||||||
|
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17,
|
||||||
|
18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
|
||||||
|
23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
|
||||||
|
24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
|
||||||
|
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
|
||||||
|
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
|
||||||
|
27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
|
||||||
|
27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
|
||||||
|
28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
|
||||||
|
28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
|
||||||
|
28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
|
||||||
|
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
|
||||||
|
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
|
||||||
|
29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
|
||||||
|
};
|
||||||
|
|
||||||
|
const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {
|
||||||
|
0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12,
|
||||||
|
13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
|
||||||
|
17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
|
||||||
|
19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
|
||||||
|
21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
|
||||||
|
22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
|
||||||
|
23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
|
||||||
|
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
|
||||||
|
25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
|
||||||
|
25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
|
||||||
|
26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
|
||||||
|
26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
|
||||||
|
27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
|
||||||
|
};
|
||||||
|
|
||||||
|
local const int base_length[LENGTH_CODES] = {
|
||||||
|
0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
|
||||||
|
64, 80, 96, 112, 128, 160, 192, 224, 0
|
||||||
|
};
|
||||||
|
|
||||||
|
local const int base_dist[D_CODES] = {
|
||||||
|
0, 1, 2, 3, 4, 6, 8, 12, 16, 24,
|
||||||
|
32, 48, 64, 96, 128, 192, 256, 384, 512, 768,
|
||||||
|
1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576
|
||||||
|
};
|
||||||
|
|
93
libraries/zlib/uncompr.c
Normal file
93
libraries/zlib/uncompr.c
Normal file
@ -0,0 +1,93 @@
|
|||||||
|
/* uncompr.c -- decompress a memory buffer
|
||||||
|
* Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* @(#) $Id$ */
|
||||||
|
|
||||||
|
#define ZLIB_INTERNAL
|
||||||
|
#include "zlib.h"
|
||||||
|
|
||||||
|
/* ===========================================================================
|
||||||
|
Decompresses the source buffer into the destination buffer. *sourceLen is
|
||||||
|
the byte length of the source buffer. Upon entry, *destLen is the total size
|
||||||
|
of the destination buffer, which must be large enough to hold the entire
|
||||||
|
uncompressed data. (The size of the uncompressed data must have been saved
|
||||||
|
previously by the compressor and transmitted to the decompressor by some
|
||||||
|
mechanism outside the scope of this compression library.) Upon exit,
|
||||||
|
*destLen is the size of the decompressed data and *sourceLen is the number
|
||||||
|
of source bytes consumed. Upon return, source + *sourceLen points to the
|
||||||
|
first unused input byte.
|
||||||
|
|
||||||
|
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||||
|
memory, Z_BUF_ERROR if there was not enough room in the output buffer, or
|
||||||
|
Z_DATA_ERROR if the input data was corrupted, including if the input data is
|
||||||
|
an incomplete zlib stream.
|
||||||
|
*/
|
||||||
|
int ZEXPORT uncompress2 (dest, destLen, source, sourceLen)
|
||||||
|
Bytef *dest;
|
||||||
|
uLongf *destLen;
|
||||||
|
const Bytef *source;
|
||||||
|
uLong *sourceLen;
|
||||||
|
{
|
||||||
|
z_stream stream;
|
||||||
|
int err;
|
||||||
|
const uInt max = (uInt)-1;
|
||||||
|
uLong len, left;
|
||||||
|
Byte buf[1]; /* for detection of incomplete stream when *destLen == 0 */
|
||||||
|
|
||||||
|
len = *sourceLen;
|
||||||
|
if (*destLen) {
|
||||||
|
left = *destLen;
|
||||||
|
*destLen = 0;
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
left = 1;
|
||||||
|
dest = buf;
|
||||||
|
}
|
||||||
|
|
||||||
|
stream.next_in = (z_const Bytef *)source;
|
||||||
|
stream.avail_in = 0;
|
||||||
|
stream.zalloc = (alloc_func)0;
|
||||||
|
stream.zfree = (free_func)0;
|
||||||
|
stream.opaque = (voidpf)0;
|
||||||
|
|
||||||
|
err = inflateInit(&stream);
|
||||||
|
if (err != Z_OK) return err;
|
||||||
|
|
||||||
|
stream.next_out = dest;
|
||||||
|
stream.avail_out = 0;
|
||||||
|
|
||||||
|
do {
|
||||||
|
if (stream.avail_out == 0) {
|
||||||
|
stream.avail_out = left > (uLong)max ? max : (uInt)left;
|
||||||
|
left -= stream.avail_out;
|
||||||
|
}
|
||||||
|
if (stream.avail_in == 0) {
|
||||||
|
stream.avail_in = len > (uLong)max ? max : (uInt)len;
|
||||||
|
len -= stream.avail_in;
|
||||||
|
}
|
||||||
|
err = inflate(&stream, Z_NO_FLUSH);
|
||||||
|
} while (err == Z_OK);
|
||||||
|
|
||||||
|
*sourceLen -= len + stream.avail_in;
|
||||||
|
if (dest != buf)
|
||||||
|
*destLen = stream.total_out;
|
||||||
|
else if (stream.total_out && err == Z_BUF_ERROR)
|
||||||
|
left = 1;
|
||||||
|
|
||||||
|
inflateEnd(&stream);
|
||||||
|
return err == Z_STREAM_END ? Z_OK :
|
||||||
|
err == Z_NEED_DICT ? Z_DATA_ERROR :
|
||||||
|
err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR :
|
||||||
|
err;
|
||||||
|
}
|
||||||
|
|
||||||
|
int ZEXPORT uncompress (dest, destLen, source, sourceLen)
|
||||||
|
Bytef *dest;
|
||||||
|
uLongf *destLen;
|
||||||
|
const Bytef *source;
|
||||||
|
uLong sourceLen;
|
||||||
|
{
|
||||||
|
return uncompress2(dest, destLen, source, &sourceLen);
|
||||||
|
}
|
536
libraries/zlib/zconf.h.cmakein
Normal file
536
libraries/zlib/zconf.h.cmakein
Normal file
@ -0,0 +1,536 @@
|
|||||||
|
/* zconf.h -- configuration of the zlib compression library
|
||||||
|
* Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* @(#) $Id$ */
|
||||||
|
|
||||||
|
#ifndef ZCONF_H
|
||||||
|
#define ZCONF_H
|
||||||
|
#cmakedefine Z_PREFIX
|
||||||
|
#cmakedefine Z_HAVE_UNISTD_H
|
||||||
|
|
||||||
|
/*
|
||||||
|
* If you *really* need a unique prefix for all types and library functions,
|
||||||
|
* compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
|
||||||
|
* Even better than compiling with -DZ_PREFIX would be to use configure to set
|
||||||
|
* this permanently in zconf.h using "./configure --zprefix".
|
||||||
|
*/
|
||||||
|
#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */
|
||||||
|
# define Z_PREFIX_SET
|
||||||
|
|
||||||
|
/* all linked symbols and init macros */
|
||||||
|
# define _dist_code z__dist_code
|
||||||
|
# define _length_code z__length_code
|
||||||
|
# define _tr_align z__tr_align
|
||||||
|
# define _tr_flush_bits z__tr_flush_bits
|
||||||
|
# define _tr_flush_block z__tr_flush_block
|
||||||
|
# define _tr_init z__tr_init
|
||||||
|
# define _tr_stored_block z__tr_stored_block
|
||||||
|
# define _tr_tally z__tr_tally
|
||||||
|
# define adler32 z_adler32
|
||||||
|
# define adler32_combine z_adler32_combine
|
||||||
|
# define adler32_combine64 z_adler32_combine64
|
||||||
|
# define adler32_z z_adler32_z
|
||||||
|
# ifndef Z_SOLO
|
||||||
|
# define compress z_compress
|
||||||
|
# define compress2 z_compress2
|
||||||
|
# define compressBound z_compressBound
|
||||||
|
# endif
|
||||||
|
# define crc32 z_crc32
|
||||||
|
# define crc32_combine z_crc32_combine
|
||||||
|
# define crc32_combine64 z_crc32_combine64
|
||||||
|
# define crc32_z z_crc32_z
|
||||||
|
# define deflate z_deflate
|
||||||
|
# define deflateBound z_deflateBound
|
||||||
|
# define deflateCopy z_deflateCopy
|
||||||
|
# define deflateEnd z_deflateEnd
|
||||||
|
# define deflateGetDictionary z_deflateGetDictionary
|
||||||
|
# define deflateInit z_deflateInit
|
||||||
|
# define deflateInit2 z_deflateInit2
|
||||||
|
# define deflateInit2_ z_deflateInit2_
|
||||||
|
# define deflateInit_ z_deflateInit_
|
||||||
|
# define deflateParams z_deflateParams
|
||||||
|
# define deflatePending z_deflatePending
|
||||||
|
# define deflatePrime z_deflatePrime
|
||||||
|
# define deflateReset z_deflateReset
|
||||||
|
# define deflateResetKeep z_deflateResetKeep
|
||||||
|
# define deflateSetDictionary z_deflateSetDictionary
|
||||||
|
# define deflateSetHeader z_deflateSetHeader
|
||||||
|
# define deflateTune z_deflateTune
|
||||||
|
# define deflate_copyright z_deflate_copyright
|
||||||
|
# define get_crc_table z_get_crc_table
|
||||||
|
# ifndef Z_SOLO
|
||||||
|
# define gz_error z_gz_error
|
||||||
|
# define gz_intmax z_gz_intmax
|
||||||
|
# define gz_strwinerror z_gz_strwinerror
|
||||||
|
# define gzbuffer z_gzbuffer
|
||||||
|
# define gzclearerr z_gzclearerr
|
||||||
|
# define gzclose z_gzclose
|
||||||
|
# define gzclose_r z_gzclose_r
|
||||||
|
# define gzclose_w z_gzclose_w
|
||||||
|
# define gzdirect z_gzdirect
|
||||||
|
# define gzdopen z_gzdopen
|
||||||
|
# define gzeof z_gzeof
|
||||||
|
# define gzerror z_gzerror
|
||||||
|
# define gzflush z_gzflush
|
||||||
|
# define gzfread z_gzfread
|
||||||
|
# define gzfwrite z_gzfwrite
|
||||||
|
# define gzgetc z_gzgetc
|
||||||
|
# define gzgetc_ z_gzgetc_
|
||||||
|
# define gzgets z_gzgets
|
||||||
|
# define gzoffset z_gzoffset
|
||||||
|
# define gzoffset64 z_gzoffset64
|
||||||
|
# define gzopen z_gzopen
|
||||||
|
# define gzopen64 z_gzopen64
|
||||||
|
# ifdef _WIN32
|
||||||
|
# define gzopen_w z_gzopen_w
|
||||||
|
# endif
|
||||||
|
# define gzprintf z_gzprintf
|
||||||
|
# define gzputc z_gzputc
|
||||||
|
# define gzputs z_gzputs
|
||||||
|
# define gzread z_gzread
|
||||||
|
# define gzrewind z_gzrewind
|
||||||
|
# define gzseek z_gzseek
|
||||||
|
# define gzseek64 z_gzseek64
|
||||||
|
# define gzsetparams z_gzsetparams
|
||||||
|
# define gztell z_gztell
|
||||||
|
# define gztell64 z_gztell64
|
||||||
|
# define gzungetc z_gzungetc
|
||||||
|
# define gzvprintf z_gzvprintf
|
||||||
|
# define gzwrite z_gzwrite
|
||||||
|
# endif
|
||||||
|
# define inflate z_inflate
|
||||||
|
# define inflateBack z_inflateBack
|
||||||
|
# define inflateBackEnd z_inflateBackEnd
|
||||||
|
# define inflateBackInit z_inflateBackInit
|
||||||
|
# define inflateBackInit_ z_inflateBackInit_
|
||||||
|
# define inflateCodesUsed z_inflateCodesUsed
|
||||||
|
# define inflateCopy z_inflateCopy
|
||||||
|
# define inflateEnd z_inflateEnd
|
||||||
|
# define inflateGetDictionary z_inflateGetDictionary
|
||||||
|
# define inflateGetHeader z_inflateGetHeader
|
||||||
|
# define inflateInit z_inflateInit
|
||||||
|
# define inflateInit2 z_inflateInit2
|
||||||
|
# define inflateInit2_ z_inflateInit2_
|
||||||
|
# define inflateInit_ z_inflateInit_
|
||||||
|
# define inflateMark z_inflateMark
|
||||||
|
# define inflatePrime z_inflatePrime
|
||||||
|
# define inflateReset z_inflateReset
|
||||||
|
# define inflateReset2 z_inflateReset2
|
||||||
|
# define inflateResetKeep z_inflateResetKeep
|
||||||
|
# define inflateSetDictionary z_inflateSetDictionary
|
||||||
|
# define inflateSync z_inflateSync
|
||||||
|
# define inflateSyncPoint z_inflateSyncPoint
|
||||||
|
# define inflateUndermine z_inflateUndermine
|
||||||
|
# define inflateValidate z_inflateValidate
|
||||||
|
# define inflate_copyright z_inflate_copyright
|
||||||
|
# define inflate_fast z_inflate_fast
|
||||||
|
# define inflate_table z_inflate_table
|
||||||
|
# ifndef Z_SOLO
|
||||||
|
# define uncompress z_uncompress
|
||||||
|
# define uncompress2 z_uncompress2
|
||||||
|
# endif
|
||||||
|
# define zError z_zError
|
||||||
|
# ifndef Z_SOLO
|
||||||
|
# define zcalloc z_zcalloc
|
||||||
|
# define zcfree z_zcfree
|
||||||
|
# endif
|
||||||
|
# define zlibCompileFlags z_zlibCompileFlags
|
||||||
|
# define zlibVersion z_zlibVersion
|
||||||
|
|
||||||
|
/* all zlib typedefs in zlib.h and zconf.h */
|
||||||
|
# define Byte z_Byte
|
||||||
|
# define Bytef z_Bytef
|
||||||
|
# define alloc_func z_alloc_func
|
||||||
|
# define charf z_charf
|
||||||
|
# define free_func z_free_func
|
||||||
|
# ifndef Z_SOLO
|
||||||
|
# define gzFile z_gzFile
|
||||||
|
# endif
|
||||||
|
# define gz_header z_gz_header
|
||||||
|
# define gz_headerp z_gz_headerp
|
||||||
|
# define in_func z_in_func
|
||||||
|
# define intf z_intf
|
||||||
|
# define out_func z_out_func
|
||||||
|
# define uInt z_uInt
|
||||||
|
# define uIntf z_uIntf
|
||||||
|
# define uLong z_uLong
|
||||||
|
# define uLongf z_uLongf
|
||||||
|
# define voidp z_voidp
|
||||||
|
# define voidpc z_voidpc
|
||||||
|
# define voidpf z_voidpf
|
||||||
|
|
||||||
|
/* all zlib structs in zlib.h and zconf.h */
|
||||||
|
# define gz_header_s z_gz_header_s
|
||||||
|
# define internal_state z_internal_state
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(__MSDOS__) && !defined(MSDOS)
|
||||||
|
# define MSDOS
|
||||||
|
#endif
|
||||||
|
#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
|
||||||
|
# define OS2
|
||||||
|
#endif
|
||||||
|
#if defined(_WINDOWS) && !defined(WINDOWS)
|
||||||
|
# define WINDOWS
|
||||||
|
#endif
|
||||||
|
#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
|
||||||
|
# ifndef WIN32
|
||||||
|
# define WIN32
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
|
||||||
|
# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
|
||||||
|
# ifndef SYS16BIT
|
||||||
|
# define SYS16BIT
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Compile with -DMAXSEG_64K if the alloc function cannot allocate more
|
||||||
|
* than 64k bytes at a time (needed on systems with 16-bit int).
|
||||||
|
*/
|
||||||
|
#ifdef SYS16BIT
|
||||||
|
# define MAXSEG_64K
|
||||||
|
#endif
|
||||||
|
#ifdef MSDOS
|
||||||
|
# define UNALIGNED_OK
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef __STDC_VERSION__
|
||||||
|
# ifndef STDC
|
||||||
|
# define STDC
|
||||||
|
# endif
|
||||||
|
# if __STDC_VERSION__ >= 199901L
|
||||||
|
# ifndef STDC99
|
||||||
|
# define STDC99
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
|
||||||
|
# define STDC
|
||||||
|
#endif
|
||||||
|
#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
|
||||||
|
# define STDC
|
||||||
|
#endif
|
||||||
|
#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
|
||||||
|
# define STDC
|
||||||
|
#endif
|
||||||
|
#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
|
||||||
|
# define STDC
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */
|
||||||
|
# define STDC
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef STDC
|
||||||
|
# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
|
||||||
|
# define const /* note: need a more gentle solution here */
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(ZLIB_CONST) && !defined(z_const)
|
||||||
|
# define z_const const
|
||||||
|
#else
|
||||||
|
# define z_const
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef Z_SOLO
|
||||||
|
typedef unsigned long z_size_t;
|
||||||
|
#else
|
||||||
|
# define z_longlong long long
|
||||||
|
# if defined(NO_SIZE_T)
|
||||||
|
typedef unsigned NO_SIZE_T z_size_t;
|
||||||
|
# elif defined(STDC)
|
||||||
|
# include <stddef.h>
|
||||||
|
typedef size_t z_size_t;
|
||||||
|
# else
|
||||||
|
typedef unsigned long z_size_t;
|
||||||
|
# endif
|
||||||
|
# undef z_longlong
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* Maximum value for memLevel in deflateInit2 */
|
||||||
|
#ifndef MAX_MEM_LEVEL
|
||||||
|
# ifdef MAXSEG_64K
|
||||||
|
# define MAX_MEM_LEVEL 8
|
||||||
|
# else
|
||||||
|
# define MAX_MEM_LEVEL 9
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* Maximum value for windowBits in deflateInit2 and inflateInit2.
|
||||||
|
* WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
|
||||||
|
* created by gzip. (Files created by minigzip can still be extracted by
|
||||||
|
* gzip.)
|
||||||
|
*/
|
||||||
|
#ifndef MAX_WBITS
|
||||||
|
# define MAX_WBITS 15 /* 32K LZ77 window */
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* The memory requirements for deflate are (in bytes):
|
||||||
|
(1 << (windowBits+2)) + (1 << (memLevel+9))
|
||||||
|
that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
|
||||||
|
plus a few kilobytes for small objects. For example, if you want to reduce
|
||||||
|
the default memory requirements from 256K to 128K, compile with
|
||||||
|
make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
|
||||||
|
Of course this will generally degrade compression (there's no free lunch).
|
||||||
|
|
||||||
|
The memory requirements for inflate are (in bytes) 1 << windowBits
|
||||||
|
that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
|
||||||
|
for small objects.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* Type declarations */
|
||||||
|
|
||||||
|
#ifndef OF /* function prototypes */
|
||||||
|
# ifdef STDC
|
||||||
|
# define OF(args) args
|
||||||
|
# else
|
||||||
|
# define OF(args) ()
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef Z_ARG /* function prototypes for stdarg */
|
||||||
|
# if defined(STDC) || defined(Z_HAVE_STDARG_H)
|
||||||
|
# define Z_ARG(args) args
|
||||||
|
# else
|
||||||
|
# define Z_ARG(args) ()
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* The following definitions for FAR are needed only for MSDOS mixed
|
||||||
|
* model programming (small or medium model with some far allocations).
|
||||||
|
* This was tested only with MSC; for other MSDOS compilers you may have
|
||||||
|
* to define NO_MEMCPY in zutil.h. If you don't need the mixed model,
|
||||||
|
* just define FAR to be empty.
|
||||||
|
*/
|
||||||
|
#ifdef SYS16BIT
|
||||||
|
# if defined(M_I86SM) || defined(M_I86MM)
|
||||||
|
/* MSC small or medium model */
|
||||||
|
# define SMALL_MEDIUM
|
||||||
|
# ifdef _MSC_VER
|
||||||
|
# define FAR _far
|
||||||
|
# else
|
||||||
|
# define FAR far
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
# if (defined(__SMALL__) || defined(__MEDIUM__))
|
||||||
|
/* Turbo C small or medium model */
|
||||||
|
# define SMALL_MEDIUM
|
||||||
|
# ifdef __BORLANDC__
|
||||||
|
# define FAR _far
|
||||||
|
# else
|
||||||
|
# define FAR far
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(WINDOWS) || defined(WIN32)
|
||||||
|
/* If building or using zlib as a DLL, define ZLIB_DLL.
|
||||||
|
* This is not mandatory, but it offers a little performance increase.
|
||||||
|
*/
|
||||||
|
# ifdef ZLIB_DLL
|
||||||
|
# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
|
||||||
|
# ifdef ZLIB_INTERNAL
|
||||||
|
# define ZEXTERN extern __declspec(dllexport)
|
||||||
|
# else
|
||||||
|
# define ZEXTERN extern __declspec(dllimport)
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
# endif /* ZLIB_DLL */
|
||||||
|
/* If building or using zlib with the WINAPI/WINAPIV calling convention,
|
||||||
|
* define ZLIB_WINAPI.
|
||||||
|
* Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
|
||||||
|
*/
|
||||||
|
# ifdef ZLIB_WINAPI
|
||||||
|
# ifdef FAR
|
||||||
|
# undef FAR
|
||||||
|
# endif
|
||||||
|
# include <windows.h>
|
||||||
|
/* No need for _export, use ZLIB.DEF instead. */
|
||||||
|
/* For complete Windows compatibility, use WINAPI, not __stdcall. */
|
||||||
|
# define ZEXPORT WINAPI
|
||||||
|
# ifdef WIN32
|
||||||
|
# define ZEXPORTVA WINAPIV
|
||||||
|
# else
|
||||||
|
# define ZEXPORTVA FAR CDECL
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined (__BEOS__)
|
||||||
|
# ifdef ZLIB_DLL
|
||||||
|
# ifdef ZLIB_INTERNAL
|
||||||
|
# define ZEXPORT __declspec(dllexport)
|
||||||
|
# define ZEXPORTVA __declspec(dllexport)
|
||||||
|
# else
|
||||||
|
# define ZEXPORT __declspec(dllimport)
|
||||||
|
# define ZEXPORTVA __declspec(dllimport)
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef ZEXTERN
|
||||||
|
# define ZEXTERN extern
|
||||||
|
#endif
|
||||||
|
#ifndef ZEXPORT
|
||||||
|
# define ZEXPORT
|
||||||
|
#endif
|
||||||
|
#ifndef ZEXPORTVA
|
||||||
|
# define ZEXPORTVA
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef FAR
|
||||||
|
# define FAR
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if !defined(__MACTYPES__)
|
||||||
|
typedef unsigned char Byte; /* 8 bits */
|
||||||
|
#endif
|
||||||
|
typedef unsigned int uInt; /* 16 bits or more */
|
||||||
|
typedef unsigned long uLong; /* 32 bits or more */
|
||||||
|
|
||||||
|
#ifdef SMALL_MEDIUM
|
||||||
|
/* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
|
||||||
|
# define Bytef Byte FAR
|
||||||
|
#else
|
||||||
|
typedef Byte FAR Bytef;
|
||||||
|
#endif
|
||||||
|
typedef char FAR charf;
|
||||||
|
typedef int FAR intf;
|
||||||
|
typedef uInt FAR uIntf;
|
||||||
|
typedef uLong FAR uLongf;
|
||||||
|
|
||||||
|
#ifdef STDC
|
||||||
|
typedef void const *voidpc;
|
||||||
|
typedef void FAR *voidpf;
|
||||||
|
typedef void *voidp;
|
||||||
|
#else
|
||||||
|
typedef Byte const *voidpc;
|
||||||
|
typedef Byte FAR *voidpf;
|
||||||
|
typedef Byte *voidp;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
|
||||||
|
# include <limits.h>
|
||||||
|
# if (UINT_MAX == 0xffffffffUL)
|
||||||
|
# define Z_U4 unsigned
|
||||||
|
# elif (ULONG_MAX == 0xffffffffUL)
|
||||||
|
# define Z_U4 unsigned long
|
||||||
|
# elif (USHRT_MAX == 0xffffffffUL)
|
||||||
|
# define Z_U4 unsigned short
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef Z_U4
|
||||||
|
typedef Z_U4 z_crc_t;
|
||||||
|
#else
|
||||||
|
typedef unsigned long z_crc_t;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */
|
||||||
|
# define Z_HAVE_UNISTD_H
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */
|
||||||
|
# define Z_HAVE_STDARG_H
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef STDC
|
||||||
|
# ifndef Z_SOLO
|
||||||
|
# include <sys/types.h> /* for off_t */
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(STDC) || defined(Z_HAVE_STDARG_H)
|
||||||
|
# ifndef Z_SOLO
|
||||||
|
# include <stdarg.h> /* for va_list */
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
# ifndef Z_SOLO
|
||||||
|
# include <stddef.h> /* for wchar_t */
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
|
||||||
|
* "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
|
||||||
|
* though the former does not conform to the LFS document), but considering
|
||||||
|
* both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
|
||||||
|
* equivalently requesting no 64-bit operations
|
||||||
|
*/
|
||||||
|
#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
|
||||||
|
# undef _LARGEFILE64_SOURCE
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
|
||||||
|
# define Z_HAVE_UNISTD_H
|
||||||
|
#endif
|
||||||
|
#ifndef Z_SOLO
|
||||||
|
# if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
|
||||||
|
# include <unistd.h> /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
|
||||||
|
# ifdef VMS
|
||||||
|
# include <unixio.h> /* for off_t */
|
||||||
|
# endif
|
||||||
|
# ifndef z_off_t
|
||||||
|
# define z_off_t off_t
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
|
||||||
|
# define Z_LFS64
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
|
||||||
|
# define Z_LARGE64
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
|
||||||
|
# define Z_WANT64
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if !defined(SEEK_SET) && !defined(Z_SOLO)
|
||||||
|
# define SEEK_SET 0 /* Seek from beginning of file. */
|
||||||
|
# define SEEK_CUR 1 /* Seek from current position. */
|
||||||
|
# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef z_off_t
|
||||||
|
# define z_off_t long
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if !defined(_WIN32) && defined(Z_LARGE64)
|
||||||
|
# define z_off64_t off64_t
|
||||||
|
#else
|
||||||
|
# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
|
||||||
|
# define z_off64_t __int64
|
||||||
|
# else
|
||||||
|
# define z_off64_t z_off_t
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* MVS linker does not support external names larger than 8 bytes */
|
||||||
|
#if defined(__MVS__)
|
||||||
|
#pragma map(deflateInit_,"DEIN")
|
||||||
|
#pragma map(deflateInit2_,"DEIN2")
|
||||||
|
#pragma map(deflateEnd,"DEEND")
|
||||||
|
#pragma map(deflateBound,"DEBND")
|
||||||
|
#pragma map(inflateInit_,"ININ")
|
||||||
|
#pragma map(inflateInit2_,"ININ2")
|
||||||
|
#pragma map(inflateEnd,"INEND")
|
||||||
|
#pragma map(inflateSync,"INSY")
|
||||||
|
#pragma map(inflateSetDictionary,"INSEDI")
|
||||||
|
#pragma map(compressBound,"CMBND")
|
||||||
|
#pragma map(inflate_table,"INTABL")
|
||||||
|
#pragma map(inflate_fast,"INFA")
|
||||||
|
#pragma map(inflate_copyright,"INCOPY")
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#endif /* ZCONF_H */
|
1935
libraries/zlib/zlib.h
Normal file
1935
libraries/zlib/zlib.h
Normal file
File diff suppressed because it is too large
Load Diff
325
libraries/zlib/zutil.c
Normal file
325
libraries/zlib/zutil.c
Normal file
@ -0,0 +1,325 @@
|
|||||||
|
/* zutil.c -- target dependent utility functions for the compression library
|
||||||
|
* Copyright (C) 1995-2017 Jean-loup Gailly
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* @(#) $Id$ */
|
||||||
|
|
||||||
|
#include "zutil.h"
|
||||||
|
#ifndef Z_SOLO
|
||||||
|
# include "gzguts.h"
|
||||||
|
#endif
|
||||||
|
|
||||||
|
z_const char * const z_errmsg[10] = {
|
||||||
|
(z_const char *)"need dictionary", /* Z_NEED_DICT 2 */
|
||||||
|
(z_const char *)"stream end", /* Z_STREAM_END 1 */
|
||||||
|
(z_const char *)"", /* Z_OK 0 */
|
||||||
|
(z_const char *)"file error", /* Z_ERRNO (-1) */
|
||||||
|
(z_const char *)"stream error", /* Z_STREAM_ERROR (-2) */
|
||||||
|
(z_const char *)"data error", /* Z_DATA_ERROR (-3) */
|
||||||
|
(z_const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */
|
||||||
|
(z_const char *)"buffer error", /* Z_BUF_ERROR (-5) */
|
||||||
|
(z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
|
||||||
|
(z_const char *)""
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
const char * ZEXPORT zlibVersion()
|
||||||
|
{
|
||||||
|
return ZLIB_VERSION;
|
||||||
|
}
|
||||||
|
|
||||||
|
uLong ZEXPORT zlibCompileFlags()
|
||||||
|
{
|
||||||
|
uLong flags;
|
||||||
|
|
||||||
|
flags = 0;
|
||||||
|
switch ((int)(sizeof(uInt))) {
|
||||||
|
case 2: break;
|
||||||
|
case 4: flags += 1; break;
|
||||||
|
case 8: flags += 2; break;
|
||||||
|
default: flags += 3;
|
||||||
|
}
|
||||||
|
switch ((int)(sizeof(uLong))) {
|
||||||
|
case 2: break;
|
||||||
|
case 4: flags += 1 << 2; break;
|
||||||
|
case 8: flags += 2 << 2; break;
|
||||||
|
default: flags += 3 << 2;
|
||||||
|
}
|
||||||
|
switch ((int)(sizeof(voidpf))) {
|
||||||
|
case 2: break;
|
||||||
|
case 4: flags += 1 << 4; break;
|
||||||
|
case 8: flags += 2 << 4; break;
|
||||||
|
default: flags += 3 << 4;
|
||||||
|
}
|
||||||
|
switch ((int)(sizeof(z_off_t))) {
|
||||||
|
case 2: break;
|
||||||
|
case 4: flags += 1 << 6; break;
|
||||||
|
case 8: flags += 2 << 6; break;
|
||||||
|
default: flags += 3 << 6;
|
||||||
|
}
|
||||||
|
#ifdef ZLIB_DEBUG
|
||||||
|
flags += 1 << 8;
|
||||||
|
#endif
|
||||||
|
#if defined(ASMV) || defined(ASMINF)
|
||||||
|
flags += 1 << 9;
|
||||||
|
#endif
|
||||||
|
#ifdef ZLIB_WINAPI
|
||||||
|
flags += 1 << 10;
|
||||||
|
#endif
|
||||||
|
#ifdef BUILDFIXED
|
||||||
|
flags += 1 << 12;
|
||||||
|
#endif
|
||||||
|
#ifdef DYNAMIC_CRC_TABLE
|
||||||
|
flags += 1 << 13;
|
||||||
|
#endif
|
||||||
|
#ifdef NO_GZCOMPRESS
|
||||||
|
flags += 1L << 16;
|
||||||
|
#endif
|
||||||
|
#ifdef NO_GZIP
|
||||||
|
flags += 1L << 17;
|
||||||
|
#endif
|
||||||
|
#ifdef PKZIP_BUG_WORKAROUND
|
||||||
|
flags += 1L << 20;
|
||||||
|
#endif
|
||||||
|
#ifdef FASTEST
|
||||||
|
flags += 1L << 21;
|
||||||
|
#endif
|
||||||
|
#if defined(STDC) || defined(Z_HAVE_STDARG_H)
|
||||||
|
# ifdef NO_vsnprintf
|
||||||
|
flags += 1L << 25;
|
||||||
|
# ifdef HAS_vsprintf_void
|
||||||
|
flags += 1L << 26;
|
||||||
|
# endif
|
||||||
|
# else
|
||||||
|
# ifdef HAS_vsnprintf_void
|
||||||
|
flags += 1L << 26;
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
#else
|
||||||
|
flags += 1L << 24;
|
||||||
|
# ifdef NO_snprintf
|
||||||
|
flags += 1L << 25;
|
||||||
|
# ifdef HAS_sprintf_void
|
||||||
|
flags += 1L << 26;
|
||||||
|
# endif
|
||||||
|
# else
|
||||||
|
# ifdef HAS_snprintf_void
|
||||||
|
flags += 1L << 26;
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
return flags;
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifdef ZLIB_DEBUG
|
||||||
|
#include <stdlib.h>
|
||||||
|
# ifndef verbose
|
||||||
|
# define verbose 0
|
||||||
|
# endif
|
||||||
|
int ZLIB_INTERNAL z_verbose = verbose;
|
||||||
|
|
||||||
|
void ZLIB_INTERNAL z_error (m)
|
||||||
|
char *m;
|
||||||
|
{
|
||||||
|
fprintf(stderr, "%s\n", m);
|
||||||
|
exit(1);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* exported to allow conversion of error code to string for compress() and
|
||||||
|
* uncompress()
|
||||||
|
*/
|
||||||
|
const char * ZEXPORT zError(err)
|
||||||
|
int err;
|
||||||
|
{
|
||||||
|
return ERR_MSG(err);
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
|
||||||
|
/* The older Microsoft C Run-Time Library for Windows CE doesn't have
|
||||||
|
* errno. We define it as a global variable to simplify porting.
|
||||||
|
* Its value is always 0 and should not be used.
|
||||||
|
*/
|
||||||
|
int errno = 0;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef HAVE_MEMCPY
|
||||||
|
|
||||||
|
void ZLIB_INTERNAL zmemcpy(dest, source, len)
|
||||||
|
Bytef* dest;
|
||||||
|
const Bytef* source;
|
||||||
|
uInt len;
|
||||||
|
{
|
||||||
|
if (len == 0) return;
|
||||||
|
do {
|
||||||
|
*dest++ = *source++; /* ??? to be unrolled */
|
||||||
|
} while (--len != 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
int ZLIB_INTERNAL zmemcmp(s1, s2, len)
|
||||||
|
const Bytef* s1;
|
||||||
|
const Bytef* s2;
|
||||||
|
uInt len;
|
||||||
|
{
|
||||||
|
uInt j;
|
||||||
|
|
||||||
|
for (j = 0; j < len; j++) {
|
||||||
|
if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
void ZLIB_INTERNAL zmemzero(dest, len)
|
||||||
|
Bytef* dest;
|
||||||
|
uInt len;
|
||||||
|
{
|
||||||
|
if (len == 0) return;
|
||||||
|
do {
|
||||||
|
*dest++ = 0; /* ??? to be unrolled */
|
||||||
|
} while (--len != 0);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef Z_SOLO
|
||||||
|
|
||||||
|
#ifdef SYS16BIT
|
||||||
|
|
||||||
|
#ifdef __TURBOC__
|
||||||
|
/* Turbo C in 16-bit mode */
|
||||||
|
|
||||||
|
# define MY_ZCALLOC
|
||||||
|
|
||||||
|
/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
|
||||||
|
* and farmalloc(64K) returns a pointer with an offset of 8, so we
|
||||||
|
* must fix the pointer. Warning: the pointer must be put back to its
|
||||||
|
* original form in order to free it, use zcfree().
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define MAX_PTR 10
|
||||||
|
/* 10*64K = 640K */
|
||||||
|
|
||||||
|
local int next_ptr = 0;
|
||||||
|
|
||||||
|
typedef struct ptr_table_s {
|
||||||
|
voidpf org_ptr;
|
||||||
|
voidpf new_ptr;
|
||||||
|
} ptr_table;
|
||||||
|
|
||||||
|
local ptr_table table[MAX_PTR];
|
||||||
|
/* This table is used to remember the original form of pointers
|
||||||
|
* to large buffers (64K). Such pointers are normalized with a zero offset.
|
||||||
|
* Since MSDOS is not a preemptive multitasking OS, this table is not
|
||||||
|
* protected from concurrent access. This hack doesn't work anyway on
|
||||||
|
* a protected system like OS/2. Use Microsoft C instead.
|
||||||
|
*/
|
||||||
|
|
||||||
|
voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
|
||||||
|
{
|
||||||
|
voidpf buf;
|
||||||
|
ulg bsize = (ulg)items*size;
|
||||||
|
|
||||||
|
(void)opaque;
|
||||||
|
|
||||||
|
/* If we allocate less than 65520 bytes, we assume that farmalloc
|
||||||
|
* will return a usable pointer which doesn't have to be normalized.
|
||||||
|
*/
|
||||||
|
if (bsize < 65520L) {
|
||||||
|
buf = farmalloc(bsize);
|
||||||
|
if (*(ush*)&buf != 0) return buf;
|
||||||
|
} else {
|
||||||
|
buf = farmalloc(bsize + 16L);
|
||||||
|
}
|
||||||
|
if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
|
||||||
|
table[next_ptr].org_ptr = buf;
|
||||||
|
|
||||||
|
/* Normalize the pointer to seg:0 */
|
||||||
|
*((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
|
||||||
|
*(ush*)&buf = 0;
|
||||||
|
table[next_ptr++].new_ptr = buf;
|
||||||
|
return buf;
|
||||||
|
}
|
||||||
|
|
||||||
|
void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
|
||||||
|
{
|
||||||
|
int n;
|
||||||
|
|
||||||
|
(void)opaque;
|
||||||
|
|
||||||
|
if (*(ush*)&ptr != 0) { /* object < 64K */
|
||||||
|
farfree(ptr);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
/* Find the original pointer */
|
||||||
|
for (n = 0; n < next_ptr; n++) {
|
||||||
|
if (ptr != table[n].new_ptr) continue;
|
||||||
|
|
||||||
|
farfree(table[n].org_ptr);
|
||||||
|
while (++n < next_ptr) {
|
||||||
|
table[n-1] = table[n];
|
||||||
|
}
|
||||||
|
next_ptr--;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
Assert(0, "zcfree: ptr not found");
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif /* __TURBOC__ */
|
||||||
|
|
||||||
|
|
||||||
|
#ifdef M_I86
|
||||||
|
/* Microsoft C in 16-bit mode */
|
||||||
|
|
||||||
|
# define MY_ZCALLOC
|
||||||
|
|
||||||
|
#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
|
||||||
|
# define _halloc halloc
|
||||||
|
# define _hfree hfree
|
||||||
|
#endif
|
||||||
|
|
||||||
|
voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
|
||||||
|
{
|
||||||
|
(void)opaque;
|
||||||
|
return _halloc((long)items, size);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
|
||||||
|
{
|
||||||
|
(void)opaque;
|
||||||
|
_hfree(ptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif /* M_I86 */
|
||||||
|
|
||||||
|
#endif /* SYS16BIT */
|
||||||
|
|
||||||
|
|
||||||
|
#ifndef MY_ZCALLOC /* Any system without a special alloc function */
|
||||||
|
|
||||||
|
#ifndef STDC
|
||||||
|
extern voidp malloc OF((uInt size));
|
||||||
|
extern voidp calloc OF((uInt items, uInt size));
|
||||||
|
extern void free OF((voidpf ptr));
|
||||||
|
#endif
|
||||||
|
|
||||||
|
voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
|
||||||
|
voidpf opaque;
|
||||||
|
unsigned items;
|
||||||
|
unsigned size;
|
||||||
|
{
|
||||||
|
(void)opaque;
|
||||||
|
return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
|
||||||
|
(voidpf)calloc(items, size);
|
||||||
|
}
|
||||||
|
|
||||||
|
void ZLIB_INTERNAL zcfree (opaque, ptr)
|
||||||
|
voidpf opaque;
|
||||||
|
voidpf ptr;
|
||||||
|
{
|
||||||
|
(void)opaque;
|
||||||
|
free(ptr);
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif /* MY_ZCALLOC */
|
||||||
|
|
||||||
|
#endif /* !Z_SOLO */
|
274
libraries/zlib/zutil.h
Normal file
274
libraries/zlib/zutil.h
Normal file
@ -0,0 +1,274 @@
|
|||||||
|
/* zutil.h -- internal interface and configuration of the compression library
|
||||||
|
* Copyright (C) 1995-2022 Jean-loup Gailly, Mark Adler
|
||||||
|
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* WARNING: this file should *not* be used by applications. It is
|
||||||
|
part of the implementation of the compression library and is
|
||||||
|
subject to change. Applications should only use zlib.h.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* @(#) $Id$ */
|
||||||
|
|
||||||
|
#ifndef ZUTIL_H
|
||||||
|
#define ZUTIL_H
|
||||||
|
|
||||||
|
#ifdef HAVE_HIDDEN
|
||||||
|
# define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
|
||||||
|
#else
|
||||||
|
# define ZLIB_INTERNAL
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#include "zlib.h"
|
||||||
|
|
||||||
|
#if defined(STDC) && !defined(Z_SOLO)
|
||||||
|
# if !(defined(_WIN32_WCE) && defined(_MSC_VER))
|
||||||
|
# include <stddef.h>
|
||||||
|
# endif
|
||||||
|
# include <string.h>
|
||||||
|
# include <stdlib.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef local
|
||||||
|
# define local static
|
||||||
|
#endif
|
||||||
|
/* since "static" is used to mean two completely different things in C, we
|
||||||
|
define "local" for the non-static meaning of "static", for readability
|
||||||
|
(compile with -Dlocal if your debugger can't find static symbols) */
|
||||||
|
|
||||||
|
typedef unsigned char uch;
|
||||||
|
typedef uch FAR uchf;
|
||||||
|
typedef unsigned short ush;
|
||||||
|
typedef ush FAR ushf;
|
||||||
|
typedef unsigned long ulg;
|
||||||
|
|
||||||
|
#if !defined(Z_U8) && !defined(Z_SOLO) && defined(STDC)
|
||||||
|
# include <limits.h>
|
||||||
|
# if (ULONG_MAX == 0xffffffffffffffff)
|
||||||
|
# define Z_U8 unsigned long
|
||||||
|
# elif (ULLONG_MAX == 0xffffffffffffffff)
|
||||||
|
# define Z_U8 unsigned long long
|
||||||
|
# elif (UINT_MAX == 0xffffffffffffffff)
|
||||||
|
# define Z_U8 unsigned
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
|
||||||
|
/* (size given to avoid silly warnings with Visual C++) */
|
||||||
|
|
||||||
|
#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
|
||||||
|
|
||||||
|
#define ERR_RETURN(strm,err) \
|
||||||
|
return (strm->msg = ERR_MSG(err), (err))
|
||||||
|
/* To be used only when the state is known to be valid */
|
||||||
|
|
||||||
|
/* common constants */
|
||||||
|
|
||||||
|
#ifndef DEF_WBITS
|
||||||
|
# define DEF_WBITS MAX_WBITS
|
||||||
|
#endif
|
||||||
|
/* default windowBits for decompression. MAX_WBITS is for compression only */
|
||||||
|
|
||||||
|
#if MAX_MEM_LEVEL >= 8
|
||||||
|
# define DEF_MEM_LEVEL 8
|
||||||
|
#else
|
||||||
|
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
|
||||||
|
#endif
|
||||||
|
/* default memLevel */
|
||||||
|
|
||||||
|
#define STORED_BLOCK 0
|
||||||
|
#define STATIC_TREES 1
|
||||||
|
#define DYN_TREES 2
|
||||||
|
/* The three kinds of block type */
|
||||||
|
|
||||||
|
#define MIN_MATCH 3
|
||||||
|
#define MAX_MATCH 258
|
||||||
|
/* The minimum and maximum match lengths */
|
||||||
|
|
||||||
|
#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
|
||||||
|
|
||||||
|
/* target dependencies */
|
||||||
|
|
||||||
|
#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
|
||||||
|
# define OS_CODE 0x00
|
||||||
|
# ifndef Z_SOLO
|
||||||
|
# if defined(__TURBOC__) || defined(__BORLANDC__)
|
||||||
|
# if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
|
||||||
|
/* Allow compilation with ANSI keywords only enabled */
|
||||||
|
void _Cdecl farfree( void *block );
|
||||||
|
void *_Cdecl farmalloc( unsigned long nbytes );
|
||||||
|
# else
|
||||||
|
# include <alloc.h>
|
||||||
|
# endif
|
||||||
|
# else /* MSC or DJGPP */
|
||||||
|
# include <malloc.h>
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef AMIGA
|
||||||
|
# define OS_CODE 1
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(VAXC) || defined(VMS)
|
||||||
|
# define OS_CODE 2
|
||||||
|
# define F_OPEN(name, mode) \
|
||||||
|
fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef __370__
|
||||||
|
# if __TARGET_LIB__ < 0x20000000
|
||||||
|
# define OS_CODE 4
|
||||||
|
# elif __TARGET_LIB__ < 0x40000000
|
||||||
|
# define OS_CODE 11
|
||||||
|
# else
|
||||||
|
# define OS_CODE 8
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(ATARI) || defined(atarist)
|
||||||
|
# define OS_CODE 5
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef OS2
|
||||||
|
# define OS_CODE 6
|
||||||
|
# if defined(M_I86) && !defined(Z_SOLO)
|
||||||
|
# include <malloc.h>
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(MACOS) || defined(TARGET_OS_MAC)
|
||||||
|
# define OS_CODE 7
|
||||||
|
# ifndef Z_SOLO
|
||||||
|
# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
|
||||||
|
# include <unix.h> /* for fdopen */
|
||||||
|
# else
|
||||||
|
# ifndef fdopen
|
||||||
|
# define fdopen(fd,mode) NULL /* No fdopen() */
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef __acorn
|
||||||
|
# define OS_CODE 13
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(WIN32) && !defined(__CYGWIN__)
|
||||||
|
# define OS_CODE 10
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef _BEOS_
|
||||||
|
# define OS_CODE 16
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef __TOS_OS400__
|
||||||
|
# define OS_CODE 18
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef __APPLE__
|
||||||
|
# define OS_CODE 19
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(_BEOS_) || defined(RISCOS)
|
||||||
|
# define fdopen(fd,mode) NULL /* No fdopen() */
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX
|
||||||
|
# if defined(_WIN32_WCE)
|
||||||
|
# define fdopen(fd,mode) NULL /* No fdopen() */
|
||||||
|
# else
|
||||||
|
# define fdopen(fd,type) _fdopen(fd,type)
|
||||||
|
# endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(__BORLANDC__) && !defined(MSDOS)
|
||||||
|
#pragma warn -8004
|
||||||
|
#pragma warn -8008
|
||||||
|
#pragma warn -8066
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* provide prototypes for these when building zlib without LFS */
|
||||||
|
#if !defined(_WIN32) && \
|
||||||
|
(!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0)
|
||||||
|
ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
|
||||||
|
ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* common defaults */
|
||||||
|
|
||||||
|
#ifndef OS_CODE
|
||||||
|
# define OS_CODE 3 /* assume Unix */
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef F_OPEN
|
||||||
|
# define F_OPEN(name, mode) fopen((name), (mode))
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* functions */
|
||||||
|
|
||||||
|
#if defined(pyr) || defined(Z_SOLO)
|
||||||
|
# define NO_MEMCPY
|
||||||
|
#endif
|
||||||
|
#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
|
||||||
|
/* Use our own functions for small and medium model with MSC <= 5.0.
|
||||||
|
* You may have to use the same strategy for Borland C (untested).
|
||||||
|
* The __SC__ check is for Symantec.
|
||||||
|
*/
|
||||||
|
# define NO_MEMCPY
|
||||||
|
#endif
|
||||||
|
#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
|
||||||
|
# define HAVE_MEMCPY
|
||||||
|
#endif
|
||||||
|
#ifdef HAVE_MEMCPY
|
||||||
|
# ifdef SMALL_MEDIUM /* MSDOS small or medium model */
|
||||||
|
# define zmemcpy _fmemcpy
|
||||||
|
# define zmemcmp _fmemcmp
|
||||||
|
# define zmemzero(dest, len) _fmemset(dest, 0, len)
|
||||||
|
# else
|
||||||
|
# define zmemcpy memcpy
|
||||||
|
# define zmemcmp memcmp
|
||||||
|
# define zmemzero(dest, len) memset(dest, 0, len)
|
||||||
|
# endif
|
||||||
|
#else
|
||||||
|
void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));
|
||||||
|
int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len));
|
||||||
|
void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len));
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/* Diagnostic functions */
|
||||||
|
#ifdef ZLIB_DEBUG
|
||||||
|
# include <stdio.h>
|
||||||
|
extern int ZLIB_INTERNAL z_verbose;
|
||||||
|
extern void ZLIB_INTERNAL z_error OF((char *m));
|
||||||
|
# define Assert(cond,msg) {if(!(cond)) z_error(msg);}
|
||||||
|
# define Trace(x) {if (z_verbose>=0) fprintf x ;}
|
||||||
|
# define Tracev(x) {if (z_verbose>0) fprintf x ;}
|
||||||
|
# define Tracevv(x) {if (z_verbose>1) fprintf x ;}
|
||||||
|
# define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
|
||||||
|
# define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
|
||||||
|
#else
|
||||||
|
# define Assert(cond,msg)
|
||||||
|
# define Trace(x)
|
||||||
|
# define Tracev(x)
|
||||||
|
# define Tracevv(x)
|
||||||
|
# define Tracec(c,x)
|
||||||
|
# define Tracecv(c,x)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef Z_SOLO
|
||||||
|
voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items,
|
||||||
|
unsigned size));
|
||||||
|
void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr));
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#define ZALLOC(strm, items, size) \
|
||||||
|
(*((strm)->zalloc))((strm)->opaque, (items), (size))
|
||||||
|
#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
|
||||||
|
#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
|
||||||
|
|
||||||
|
/* Reverse the bytes in a 32-bit value */
|
||||||
|
#define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
|
||||||
|
(((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
|
||||||
|
|
||||||
|
#endif /* ZUTIL_H */
|
Loading…
Reference in New Issue
Block a user