/programs/develop/libraries/newlib/sdk/fasm/include/libfreetype.inc |
---|
345,4 → 345,4 |
tt_cmap8_class_rec,'tt_cmap8_class_rec',\ |
tt_default_graphics_state,'tt_default_graphics_state',\ |
tt_driver_class,'tt_driver_class',\ |
winfnt_driver_class,'winfnt_driver_class',\ |
winfnt_driver_class,'winfnt_driver_class' |
/programs/develop/libraries/zlib/FAQ |
---|
44,8 → 44,8 |
6. Where's the zlib documentation (man pages, etc.)? |
It's in zlib.h . Examples of zlib usage are in the files example.c and |
minigzip.c, with more in examples/ . |
It's in zlib.h . Examples of zlib usage are in the files test/example.c |
and test/minigzip.c, with more in examples/ . |
7. Why don't you use GNU autoconf or libtool or ...? |
84,8 → 84,10 |
13. How can I make a Unix shared library? |
make clean |
./configure -s |
By default a shared (and a static) library is built for Unix. So: |
make distclean |
./configure |
make |
14. How do I install a shared zlib library on Unix? |
325,7 → 327,7 |
correctly points to the zlib specification in RFC 1950 for the "deflate" |
transfer encoding, there have been reports of servers and browsers that |
incorrectly produce or expect raw deflate data per the deflate |
specficiation in RFC 1951, most notably Microsoft. So even though the |
specification in RFC 1951, most notably Microsoft. So even though the |
"deflate" transfer encoding using the zlib format would be the more |
efficient approach (and in fact exactly what the zlib format was designed |
for), using the "gzip" transfer encoding is probably more reliable due to |
/programs/develop/libraries/zlib/Makefile |
---|
1,46 → 1,80 |
# Makefile for zlib |
# Copyright (C) 1995-2010 Jean-loup Gailly. |
# Makefile for zlib, derived from Makefile.dj2. |
# Modified for mingw32 by C. Spieler, 6/16/98. |
# Updated for zlib 1.2.x by Christian Spieler and Cosmin Truta, Mar-2003. |
# Last updated: Mar 2012. |
# Tested under Cygwin and MinGW. |
# Copyright (C) 1995-2003 Jean-loup Gailly. |
# For conditions of distribution and use, see copyright notice in zlib.h |
CC=gcc |
CPP=gcc -E |
STATICLIB = libz.a |
SHAREDLIB = zlib.dll |
IMPLIB = libz.dll.a |
CFLAGS= -O3 -c -fomit-frame-pointer |
PREFIX = |
CC = $(PREFIX)gcc |
CFLAGS = $(LOC) -U_Win32 -U_WIN32 -U__MINGW32__ -O3 -Wall -fomit-frame-pointer |
AS = $(CC) |
ASFLAGS = $(LOC) -Wall |
LD = ld |
LDFLAGS = $(LOC) |
AR = $(PREFIX)ar |
ARFLAGS = rcs |
STRIP = $(PREFIX)strip |
LDIMPORT:= -nostdlib --out-implib libzimp.a |
LDFLAGS:= -shared -s -T ../newlib/dll.lds --image-base 0 |
LDFLAGS:= -shared -s -nostdlib -T ../newlib/dll.lds --entry _DllStartup --image-base=0 --out-implib $(IMPLIB) |
INCLUDES= -I../newlib/include |
LIBPATH:= -L../newlib |
LIBS:= -lamz -lgcc -lcimp |
LIBS:= -ldll -lc.dll |
AR=ar rc |
OBJC = adler32.o compress.o crc32.o deflate.o \ |
gzclose.o gzlib.o gzread.o gzwrite.o \ |
infback.o inffast.o inflate.o inftrees.o \ |
trees.o uncompr.o zutil.o |
OBJS = adler32.o compress.o crc32.o deflate.o gzclose.o gzlib.o gzread.o \ |
gzwrite.o infback.o inffast.o inflate.o inftrees.o trees.o uncompr.o zutil.o |
OBJA = |
all: $(STATICLIB) $(SHAREDLIB) $(IMPLIB) |
# to use the asm code: make OBJA=match.o, PIC_OBJA=match.lo |
OBJA = |
OBJS = $(OBJC) $(OBJA) |
.c.o: |
$(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $< |
all: libz.a zlib.dll |
.S.o: |
$(AS) $(ASFLAGS) -c -o $@ $< |
libz.a: $(OBJS) |
$(AR) $@ $(OBJS) |
$(STATICLIB): $(OBJS) $(OBJA) |
$(AR) $(ARFLAGS) $@ $(OBJS) $(OBJA) |
zlib.dll: $(OBJECTS) Makefile |
# dlltool -d zlib.def -Dlibz.dll -e exports.o -l libzimp.a |
ld $(LDFLAGS) $(LDIMPORT) $(LIBPATH) -o $@ $(OBJS) $(LIBS) zlib.def |
$(IMPLIB): $(SHAREDLIB) |
$(SHAREDLIB): zlib.def $(OBJS) $(OBJA) |
$(LD) $(LDFLAGS) $(LIBPATH) -o $@ zlib.def $(OBJS) $(OBJA) $(LIBS) |
$(STRIP) $@ |
sed -f ../newlib/cmd1.sed zlib.def > mem |
sed -f ../newlib/cmd2.sed mem >zlib.inc |
%.o: %.c Makefile |
$(CC) $(CFLAGS) $(INCLUDES) -o $@ $< |
adler32.o: zlib.h zconf.h |
compress.o: zlib.h zconf.h |
crc32.o: crc32.h zlib.h zconf.h |
deflate.o: deflate.h zutil.h zlib.h zconf.h |
gzclose.o: zlib.h zconf.h gzguts.h |
gzlib.o: zlib.h zconf.h gzguts.h |
gzread.o: zlib.h zconf.h gzguts.h |
gzwrite.o: zlib.h zconf.h gzguts.h |
inffast.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h |
inflate.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h |
infback.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h |
inftrees.o: zutil.h zlib.h zconf.h inftrees.h |
trees.o: deflate.h zutil.h zlib.h zconf.h trees.h |
uncompr.o: zlib.h zconf.h |
zutil.o: zutil.h zlib.h zconf.h |
/programs/develop/libraries/zlib/README |
---|
1,22 → 1,22 |
ZLIB DATA COMPRESSION LIBRARY |
zlib 1.2.5 is a general purpose data compression library. All the code is |
zlib 1.2.8 is a general purpose data compression library. All the code is |
thread safe. The data format used by the zlib library is described by RFCs |
(Request for Comments) 1950 to 1952 in the files |
http://www.ietf.org/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate format) |
and rfc1952.txt (gzip format). |
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 example.c which also tests that the library |
is working correctly. Another example is given in the file minigzip.c. The |
compression library itself is composed of all source files except example.c and |
minigzip.c. |
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 |
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 |
31,7 → 31,7 |
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.5 are documented in the file ChangeLog. |
The changes made in version 1.2.8 are documented in the file ChangeLog. |
Unsupported third party contributions are provided in directory contrib/ . |
44,7 → 44,7 |
A Python interface to zlib written by A.M. Kuchling <amk@amk.ca> is |
available in Python 1.5 and later versions, see |
http://www.python.org/doc/lib/module-zlib.html . |
http://docs.python.org/library/zlib.html . |
zlib is built into tcl: http://wiki.tcl.tk/4610 . |
84,7 → 84,7 |
Copyright notice: |
(C) 1995-2010 Jean-loup Gailly and Mark Adler |
(C) 1995-2013 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 |
/programs/develop/libraries/zlib/adler32.c |
---|
1,5 → 1,5 |
/* adler32.c -- compute the Adler-32 checksum of a data stream |
* Copyright (C) 1995-2007 Mark Adler |
* Copyright (C) 1995-2011 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
9,9 → 9,9 |
#define local static |
local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2); |
local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2)); |
#define BASE 65521UL /* largest prime smaller than 65536 */ |
#define BASE 65521 /* 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 */ |
21,39 → 21,44 |
#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 */ |
/* use NO_DIVIDE if your processor does not do division in hardware -- |
try it both ways to see which is faster */ |
#ifdef NO_DIVIDE |
# define MOD(a) \ |
/* note that this assumes BASE is 65521, where 65536 % 65521 == 15 |
(thank you to John Reiser for pointing this out) */ |
# define CHOP(a) \ |
do { \ |
if (a >= (BASE << 16)) a -= (BASE << 16); \ |
if (a >= (BASE << 15)) a -= (BASE << 15); \ |
if (a >= (BASE << 14)) a -= (BASE << 14); \ |
if (a >= (BASE << 13)) a -= (BASE << 13); \ |
if (a >= (BASE << 12)) a -= (BASE << 12); \ |
if (a >= (BASE << 11)) a -= (BASE << 11); \ |
if (a >= (BASE << 10)) a -= (BASE << 10); \ |
if (a >= (BASE << 9)) a -= (BASE << 9); \ |
if (a >= (BASE << 8)) a -= (BASE << 8); \ |
if (a >= (BASE << 7)) a -= (BASE << 7); \ |
if (a >= (BASE << 6)) a -= (BASE << 6); \ |
if (a >= (BASE << 5)) a -= (BASE << 5); \ |
if (a >= (BASE << 4)) a -= (BASE << 4); \ |
if (a >= (BASE << 3)) a -= (BASE << 3); \ |
if (a >= (BASE << 2)) a -= (BASE << 2); \ |
if (a >= (BASE << 1)) a -= (BASE << 1); \ |
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 MOD4(a) \ |
# define MOD(a) \ |
do { \ |
if (a >= (BASE << 4)) a -= (BASE << 4); \ |
if (a >= (BASE << 3)) a -= (BASE << 3); \ |
if (a >= (BASE << 2)) a -= (BASE << 2); \ |
if (a >= (BASE << 1)) a -= (BASE << 1); \ |
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 MOD4(a) a %= BASE |
# define MOD28(a) a %= BASE |
# define MOD63(a) a %= BASE |
#endif |
/* ========================================================================= */ |
92,7 → 97,7 |
} |
if (adler >= BASE) |
adler -= BASE; |
MOD4(sum2); /* only added so many BASE's */ |
MOD28(sum2); /* only added so many BASE's */ |
return adler | (sum2 << 16); |
} |
137,8 → 142,13 |
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 */ |
rem = (unsigned)(len2 % BASE); |
MOD63(len2); /* assumes len2 >= 0 */ |
rem = (unsigned)len2; |
sum1 = adler1 & 0xffff; |
sum2 = rem * sum1; |
MOD(sum2); |
/programs/develop/libraries/zlib/compress.c |
---|
29,7 → 29,7 |
z_stream stream; |
int err; |
stream.next_in = (Bytef*)source; |
stream.next_in = (z_const Bytef *)source; |
stream.avail_in = (uInt)sourceLen; |
#ifdef MAXSEG_64K |
/* Check for source > 64K on 16-bit machine: */ |
/programs/develop/libraries/zlib/crc32.c |
---|
1,5 → 1,5 |
/* crc32.c -- compute the CRC-32 of a data stream |
* Copyright (C) 1995-2006, 2010 Mark Adler |
* Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
* |
* Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster |
17,6 → 17,8 |
of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should |
first call get_crc_table() to initialize the tables before allowing more than |
one thread to use crc32(). |
DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h. |
*/ |
#ifdef MAKECRCH |
30,31 → 32,11 |
#define local static |
/* Find a four-byte integer type for crc32_little() and crc32_big(). */ |
#ifndef NOBYFOUR |
# ifdef STDC /* need ANSI C limits.h to determine sizes */ |
# include <limits.h> |
/* Definitions for doing the crc four data bytes at a time. */ |
#if !defined(NOBYFOUR) && defined(Z_U4) |
# define BYFOUR |
# if (UINT_MAX == 0xffffffffUL) |
typedef unsigned int u4; |
# else |
# if (ULONG_MAX == 0xffffffffUL) |
typedef unsigned long u4; |
# else |
# if (USHRT_MAX == 0xffffffffUL) |
typedef unsigned short u4; |
# else |
# undef BYFOUR /* can't find a four-byte integer type! */ |
# endif |
# endif |
# endif |
# endif /* STDC */ |
#endif /* !NOBYFOUR */ |
/* Definitions for doing the crc four data bytes at a time. */ |
#ifdef BYFOUR |
# define REV(w) ((((w)>>24)&0xff)+(((w)>>8)&0xff00)+ \ |
(((w)&0xff00)<<8)+(((w)&0xff)<<24)) |
local unsigned long crc32_little OF((unsigned long, |
const unsigned char FAR *, unsigned)); |
local unsigned long crc32_big OF((unsigned long, |
68,16 → 50,16 |
local unsigned long gf2_matrix_times OF((unsigned long *mat, |
unsigned long vec)); |
local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); |
local uLong crc32_combine_(uLong crc1, uLong crc2, z_off64_t len2); |
local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2)); |
#ifdef DYNAMIC_CRC_TABLE |
local volatile int crc_table_empty = 1; |
local unsigned long FAR crc_table[TBLS][256]; |
local z_crc_t FAR crc_table[TBLS][256]; |
local void make_crc_table OF((void)); |
#ifdef MAKECRCH |
local void write_table OF((FILE *, const unsigned long FAR *)); |
local void write_table OF((FILE *, const z_crc_t FAR *)); |
#endif /* MAKECRCH */ |
/* |
Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: |
107,9 → 89,9 |
*/ |
local void make_crc_table() |
{ |
unsigned long c; |
z_crc_t c; |
int n, k; |
unsigned long poly; /* polynomial exclusive-or pattern */ |
z_crc_t poly; /* polynomial exclusive-or pattern */ |
/* terms of polynomial defining this crc (except x^32): */ |
static volatile int first = 1; /* flag to limit concurrent making */ |
static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; |
121,13 → 103,13 |
first = 0; |
/* make exclusive-or pattern from polynomial (0xedb88320UL) */ |
poly = 0UL; |
for (n = 0; n < sizeof(p)/sizeof(unsigned char); n++) |
poly |= 1UL << (31 - p[n]); |
poly = 0; |
for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++) |
poly |= (z_crc_t)1 << (31 - p[n]); |
/* generate a crc for every 8-bit value */ |
for (n = 0; n < 256; n++) { |
c = (unsigned long)n; |
c = (z_crc_t)n; |
for (k = 0; k < 8; k++) |
c = c & 1 ? poly ^ (c >> 1) : c >> 1; |
crc_table[0][n] = c; |
138,11 → 120,11 |
and then the byte reversal of those as well as the first table */ |
for (n = 0; n < 256; n++) { |
c = crc_table[0][n]; |
crc_table[4][n] = REV(c); |
crc_table[4][n] = ZSWAP32(c); |
for (k = 1; k < 4; k++) { |
c = crc_table[0][c & 0xff] ^ (c >> 8); |
crc_table[k][n] = c; |
crc_table[k + 4][n] = REV(c); |
crc_table[k + 4][n] = ZSWAP32(c); |
} |
} |
#endif /* BYFOUR */ |
164,7 → 146,7 |
if (out == NULL) return; |
fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); |
fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); |
fprintf(out, "local const unsigned long FAR "); |
fprintf(out, "local const z_crc_t FAR "); |
fprintf(out, "crc_table[TBLS][256] =\n{\n {\n"); |
write_table(out, crc_table[0]); |
# ifdef BYFOUR |
184,12 → 166,13 |
#ifdef MAKECRCH |
local void write_table(out, table) |
FILE *out; |
const unsigned long FAR *table; |
const z_crc_t FAR *table; |
{ |
int n; |
for (n = 0; n < 256; n++) |
fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", table[n], |
fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", |
(unsigned long)(table[n]), |
n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); |
} |
#endif /* MAKECRCH */ |
204,13 → 187,13 |
/* ========================================================================= |
* This function can be used by asm versions of crc32() |
*/ |
const unsigned long FAR * ZEXPORT get_crc_table() |
const z_crc_t FAR * ZEXPORT get_crc_table() |
{ |
#ifdef DYNAMIC_CRC_TABLE |
if (crc_table_empty) |
make_crc_table(); |
#endif /* DYNAMIC_CRC_TABLE */ |
return (const unsigned long FAR *)crc_table; |
return (const z_crc_t FAR *)crc_table; |
} |
/* ========================================================================= */ |
232,7 → 215,7 |
#ifdef BYFOUR |
if (sizeof(void *) == sizeof(ptrdiff_t)) { |
u4 endian; |
z_crc_t endian; |
endian = 1; |
if (*((unsigned char *)(&endian))) |
266,10 → 249,10 |
const unsigned char FAR *buf; |
unsigned len; |
{ |
register u4 c; |
register const u4 FAR *buf4; |
register z_crc_t c; |
register const z_crc_t FAR *buf4; |
c = (u4)crc; |
c = (z_crc_t)crc; |
c = ~c; |
while (len && ((ptrdiff_t)buf & 3)) { |
c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); |
276,7 → 259,7 |
len--; |
} |
buf4 = (const u4 FAR *)(const void FAR *)buf; |
buf4 = (const z_crc_t FAR *)(const void FAR *)buf; |
while (len >= 32) { |
DOLIT32; |
len -= 32; |
306,10 → 289,10 |
const unsigned char FAR *buf; |
unsigned len; |
{ |
register u4 c; |
register const u4 FAR *buf4; |
register z_crc_t c; |
register const z_crc_t FAR *buf4; |
c = REV((u4)crc); |
c = ZSWAP32((z_crc_t)crc); |
c = ~c; |
while (len && ((ptrdiff_t)buf & 3)) { |
c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); |
316,7 → 299,7 |
len--; |
} |
buf4 = (const u4 FAR *)(const void FAR *)buf; |
buf4 = (const z_crc_t FAR *)(const void FAR *)buf; |
buf4--; |
while (len >= 32) { |
DOBIG32; |
333,7 → 316,7 |
c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); |
} while (--len); |
c = ~c; |
return (unsigned long)(REV(c)); |
return (unsigned long)(ZSWAP32(c)); |
} |
#endif /* BYFOUR */ |
/programs/develop/libraries/zlib/crc32.h |
---|
2,7 → 2,7 |
* Generated automatically by crc32.c |
*/ |
local const unsigned long FAR crc_table[TBLS][256] = |
local const z_crc_t FAR crc_table[TBLS][256] = |
{ |
{ |
0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL, |
/programs/develop/libraries/zlib/deflate.c |
---|
1,5 → 1,5 |
/* deflate.c -- compress data using the deflation algorithm |
* Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler |
* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
37,7 → 37,7 |
* REFERENCES |
* |
* Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". |
* Available in http://www.ietf.org/rfc/rfc1951.txt |
* Available in http://tools.ietf.org/html/rfc1951 |
* |
* A description of the Rabin and Karp algorithm is given in the book |
* "Algorithms" by R. Sedgewick, Addison-Wesley, p252. |
52,7 → 52,7 |
#include "deflate.h" |
const char deflate_copyright[] = |
" deflate 1.2.5 Copyright 1995-2010 Jean-loup Gailly and Mark Adler "; |
" deflate 1.2.8 Copyright 1995-2013 Jean-loup Gailly and 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 |
155,6 → 155,9 |
struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ |
#endif |
/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */ |
#define RANK(f) (((f) << 1) - ((f) > 4 ? 9 : 0)) |
/* =========================================================================== |
* Update a hash value with the given input byte |
* IN assertion: all calls to to UPDATE_HASH are made with consecutive |
235,10 → 238,19 |
strm->msg = Z_NULL; |
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) strm->zfree = zcfree; |
if (strm->zfree == (free_func)0) |
#ifdef Z_SOLO |
return Z_STREAM_ERROR; |
#else |
strm->zfree = zcfree; |
#endif |
#ifdef FASTEST |
if (level != 0) level = 1; |
293,7 → 305,7 |
if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || |
s->pending_buf == Z_NULL) { |
s->status = FINISH_STATE; |
strm->msg = (char*)ERR_MSG(Z_MEM_ERROR); |
strm->msg = ERR_MSG(Z_MEM_ERROR); |
deflateEnd (strm); |
return Z_MEM_ERROR; |
} |
314,43 → 326,70 |
uInt dictLength; |
{ |
deflate_state *s; |
uInt length = dictLength; |
uInt n; |
IPos hash_head = 0; |
uInt str, n; |
int wrap; |
unsigned avail; |
z_const unsigned char *next; |
if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL || |
strm->state->wrap == 2 || |
(strm->state->wrap == 1 && strm->state->status != INIT_STATE)) |
if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL) |
return Z_STREAM_ERROR; |
s = strm->state; |
wrap = s->wrap; |
if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead) |
return Z_STREAM_ERROR; |
s = strm->state; |
if (s->wrap) |
/* when using zlib wrappers, compute Adler-32 for provided dictionary */ |
if (wrap == 1) |
strm->adler = adler32(strm->adler, dictionary, dictLength); |
s->wrap = 0; /* avoid computing Adler-32 in read_buf */ |
if (length < MIN_MATCH) return Z_OK; |
if (length > s->w_size) { |
length = s->w_size; |
dictionary += dictLength - length; /* use the tail of the dictionary */ |
/* if dictionary would fill window, just replace the history */ |
if (dictLength >= s->w_size) { |
if (wrap == 0) { /* already empty otherwise */ |
CLEAR_HASH(s); |
s->strstart = 0; |
s->block_start = 0L; |
s->insert = 0; |
} |
zmemcpy(s->window, dictionary, length); |
s->strstart = length; |
s->block_start = (long)length; |
dictionary += dictLength - s->w_size; /* use the tail */ |
dictLength = s->w_size; |
} |
/* Insert all strings in the hash table (except for the last two bytes). |
* s->lookahead stays null, so s->ins_h will be recomputed at the next |
* call of fill_window. |
*/ |
s->ins_h = s->window[0]; |
UPDATE_HASH(s, s->ins_h, s->window[1]); |
for (n = 0; n <= length - MIN_MATCH; n++) { |
INSERT_STRING(s, n, hash_head); |
/* insert dictionary into window and hash */ |
avail = strm->avail_in; |
next = strm->next_in; |
strm->avail_in = dictLength; |
strm->next_in = (z_const Bytef *)dictionary; |
fill_window(s); |
while (s->lookahead >= MIN_MATCH) { |
str = s->strstart; |
n = s->lookahead - (MIN_MATCH-1); |
do { |
UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); |
#ifndef FASTEST |
s->prev[str & s->w_mask] = s->head[s->ins_h]; |
#endif |
s->head[s->ins_h] = (Pos)str; |
str++; |
} while (--n); |
s->strstart = str; |
s->lookahead = MIN_MATCH-1; |
fill_window(s); |
} |
if (hash_head) hash_head = 0; /* to make compiler happy */ |
s->strstart += s->lookahead; |
s->block_start = (long)s->strstart; |
s->insert = s->lookahead; |
s->lookahead = 0; |
s->match_length = s->prev_length = MIN_MATCH-1; |
s->match_available = 0; |
strm->next_in = next; |
strm->avail_in = avail; |
s->wrap = wrap; |
return Z_OK; |
} |
/* ========================================================================= */ |
int ZEXPORT deflateReset (strm) |
int ZEXPORT deflateResetKeep (strm) |
z_streamp strm; |
{ |
deflate_state *s; |
380,12 → 419,23 |
s->last_flush = Z_NO_FLUSH; |
_tr_init(s); |
lm_init(s); |
return Z_OK; |
} |
/* ========================================================================= */ |
int ZEXPORT deflateReset (strm) |
z_streamp strm; |
{ |
int ret; |
ret = deflateResetKeep(strm); |
if (ret == Z_OK) |
lm_init(strm->state); |
return ret; |
} |
/* ========================================================================= */ |
int ZEXPORT deflateSetHeader (strm, head) |
z_streamp strm; |
gz_headerp head; |
397,14 → 447,42 |
} |
/* ========================================================================= */ |
int ZEXPORT deflatePending (strm, pending, bits) |
unsigned *pending; |
int *bits; |
z_streamp strm; |
{ |
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
if (pending != Z_NULL) |
*pending = strm->state->pending; |
if (bits != Z_NULL) |
*bits = strm->state->bi_valid; |
return Z_OK; |
} |
/* ========================================================================= */ |
int ZEXPORT deflatePrime (strm, bits, value) |
z_streamp strm; |
int bits; |
int value; |
{ |
deflate_state *s; |
int put; |
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
strm->state->bi_valid = bits; |
strm->state->bi_buf = (ush)(value & ((1 << bits) - 1)); |
s = strm->state; |
if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3)) |
return Z_BUF_ERROR; |
do { |
put = Buf_size - s->bi_valid; |
if (put > bits) |
put = bits; |
s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid); |
s->bi_valid += put; |
_tr_flush_bits(s); |
value >>= put; |
bits -= put; |
} while (bits); |
return Z_OK; |
} |
435,6 → 513,8 |
strm->total_in != 0) { |
/* Flush the last buffer: */ |
err = deflate(strm, Z_BLOCK); |
if (err == Z_BUF_ERROR && s->pending == 0) |
err = Z_OK; |
} |
if (s->level != level) { |
s->level = level; |
562,19 → 642,22 |
local void flush_pending(strm) |
z_streamp strm; |
{ |
unsigned len = strm->state->pending; |
unsigned len; |
deflate_state *s = strm->state; |
_tr_flush_bits(s); |
len = s->pending; |
if (len > strm->avail_out) len = strm->avail_out; |
if (len == 0) return; |
zmemcpy(strm->next_out, strm->state->pending_out, len); |
zmemcpy(strm->next_out, s->pending_out, len); |
strm->next_out += len; |
strm->state->pending_out += len; |
s->pending_out += len; |
strm->total_out += len; |
strm->avail_out -= len; |
strm->state->pending -= len; |
if (strm->state->pending == 0) { |
strm->state->pending_out = strm->state->pending_buf; |
s->pending -= len; |
if (s->pending == 0) { |
s->pending_out = s->pending_buf; |
} |
} |
801,7 → 884,7 |
* flushes. For repeated and useless calls with Z_FINISH, we keep |
* returning Z_STREAM_END instead of Z_BUF_ERROR. |
*/ |
} else if (strm->avail_in == 0 && flush <= old_flush && |
} else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) && |
flush != Z_FINISH) { |
ERR_RETURN(strm, Z_BUF_ERROR); |
} |
850,6 → 933,7 |
if (s->lookahead == 0) { |
s->strstart = 0; |
s->block_start = 0L; |
s->insert = 0; |
} |
} |
} |
945,12 → 1029,12 |
ss = source->state; |
zmemcpy(dest, source, sizeof(z_stream)); |
zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); |
ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); |
if (ds == Z_NULL) return Z_MEM_ERROR; |
dest->state = (struct internal_state FAR *) ds; |
zmemcpy(ds, ss, sizeof(deflate_state)); |
zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state)); |
ds->strm = dest; |
ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); |
966,8 → 1050,8 |
} |
/* following zmemcpy do not work for 16-bit MSDOS */ |
zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); |
zmemcpy(ds->prev, ss->prev, ds->w_size * sizeof(Pos)); |
zmemcpy(ds->head, ss->head, ds->hash_size * sizeof(Pos)); |
zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos)); |
zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos)); |
zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); |
ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); |
1001,15 → 1085,15 |
strm->avail_in -= len; |
zmemcpy(buf, strm->next_in, len); |
if (strm->state->wrap == 1) { |
strm->adler = adler32(strm->adler, strm->next_in, len); |
strm->adler = adler32(strm->adler, buf, len); |
} |
#ifdef GZIP |
else if (strm->state->wrap == 2) { |
strm->adler = crc32(strm->adler, strm->next_in, len); |
strm->adler = crc32(strm->adler, buf, len); |
} |
#endif |
zmemcpy(buf, strm->next_in, len); |
strm->next_in += len; |
strm->total_in += len; |
1036,6 → 1120,7 |
s->strstart = 0; |
s->block_start = 0L; |
s->lookahead = 0; |
s->insert = 0; |
s->match_length = s->prev_length = MIN_MATCH-1; |
s->match_available = 0; |
s->ins_h = 0; |
1310,6 → 1395,8 |
unsigned more; /* Amount of free space at the end of the window. */ |
uInt wsize = s->w_size; |
Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); |
do { |
more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); |
1362,7 → 1449,7 |
#endif |
more += wsize; |
} |
if (s->strm->avail_in == 0) return; |
if (s->strm->avail_in == 0) break; |
/* If there was no sliding: |
* strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && |
1381,13 → 1468,25 |
s->lookahead += n; |
/* Initialize the hash value now that we have some input: */ |
if (s->lookahead >= MIN_MATCH) { |
s->ins_h = s->window[s->strstart]; |
UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); |
if (s->lookahead + s->insert >= MIN_MATCH) { |
uInt str = s->strstart - s->insert; |
s->ins_h = s->window[str]; |
UPDATE_HASH(s, s->ins_h, s->window[str + 1]); |
#if MIN_MATCH != 3 |
Call UPDATE_HASH() MIN_MATCH-3 more times |
#endif |
while (s->insert) { |
UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); |
#ifndef FASTEST |
s->prev[str & s->w_mask] = s->head[s->ins_h]; |
#endif |
s->head[s->ins_h] = (Pos)str; |
str++; |
s->insert--; |
if (s->lookahead + s->insert < MIN_MATCH) |
break; |
} |
} |
/* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, |
* but this is not important since only literal bytes will be emitted. |
*/ |
1427,6 → 1526,9 |
s->high_water += init; |
} |
} |
Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, |
"not enough room for search"); |
} |
/* =========================================================================== |
1506,9 → 1608,15 |
FLUSH_BLOCK(s, 0); |
} |
} |
FLUSH_BLOCK(s, flush == Z_FINISH); |
return flush == Z_FINISH ? finish_done : block_done; |
s->insert = 0; |
if (flush == Z_FINISH) { |
FLUSH_BLOCK(s, 1); |
return finish_done; |
} |
if ((long)s->strstart > s->block_start) |
FLUSH_BLOCK(s, 0); |
return block_done; |
} |
/* =========================================================================== |
* Compress as much as possible from the input stream, return the current |
1603,9 → 1711,15 |
} |
if (bflush) FLUSH_BLOCK(s, 0); |
} |
FLUSH_BLOCK(s, flush == Z_FINISH); |
return flush == Z_FINISH ? finish_done : block_done; |
s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; |
if (flush == Z_FINISH) { |
FLUSH_BLOCK(s, 1); |
return finish_done; |
} |
if (s->last_lit) |
FLUSH_BLOCK(s, 0); |
return block_done; |
} |
#ifndef FASTEST |
/* =========================================================================== |
1728,9 → 1842,15 |
_tr_tally_lit(s, s->window[s->strstart-1], bflush); |
s->match_available = 0; |
} |
FLUSH_BLOCK(s, flush == Z_FINISH); |
return flush == Z_FINISH ? finish_done : block_done; |
s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; |
if (flush == Z_FINISH) { |
FLUSH_BLOCK(s, 1); |
return finish_done; |
} |
if (s->last_lit) |
FLUSH_BLOCK(s, 0); |
return block_done; |
} |
#endif /* FASTEST */ |
/* =========================================================================== |
1749,11 → 1869,11 |
for (;;) { |
/* Make sure that we always have enough lookahead, except |
* at the end of the input file. We need MAX_MATCH bytes |
* for the longest encodable run. |
* for the longest run, plus one for the unrolled loop. |
*/ |
if (s->lookahead < MAX_MATCH) { |
if (s->lookahead <= MAX_MATCH) { |
fill_window(s); |
if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) { |
if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) { |
return need_more; |
} |
if (s->lookahead == 0) break; /* flush the current block */ |
1776,6 → 1896,7 |
if (s->match_length > s->lookahead) |
s->match_length = s->lookahead; |
} |
Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan"); |
} |
/* Emit match if have run of MIN_MATCH or longer, else emit literal */ |
1796,9 → 1917,15 |
} |
if (bflush) FLUSH_BLOCK(s, 0); |
} |
FLUSH_BLOCK(s, flush == Z_FINISH); |
return flush == Z_FINISH ? finish_done : block_done; |
s->insert = 0; |
if (flush == Z_FINISH) { |
FLUSH_BLOCK(s, 1); |
return finish_done; |
} |
if (s->last_lit) |
FLUSH_BLOCK(s, 0); |
return block_done; |
} |
/* =========================================================================== |
* For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. |
1829,6 → 1956,12 |
s->strstart++; |
if (bflush) FLUSH_BLOCK(s, 0); |
} |
FLUSH_BLOCK(s, flush == Z_FINISH); |
return flush == Z_FINISH ? finish_done : block_done; |
s->insert = 0; |
if (flush == Z_FINISH) { |
FLUSH_BLOCK(s, 1); |
return finish_done; |
} |
if (s->last_lit) |
FLUSH_BLOCK(s, 0); |
return block_done; |
} |
/programs/develop/libraries/zlib/deflate.h |
---|
1,5 → 1,5 |
/* deflate.h -- internal compression state |
* Copyright (C) 1995-2010 Jean-loup Gailly |
* Copyright (C) 1995-2012 Jean-loup Gailly |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
48,6 → 48,9 |
#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 |
#define EXTRA_STATE 69 |
#define NAME_STATE 73 |
101,7 → 104,7 |
int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ |
gz_headerp gzhead; /* gzip header information to write */ |
uInt gzindex; /* where in extra, name, or comment */ |
Byte method; /* STORED (for zip only) or DEFLATED */ |
Byte method; /* can only be DEFLATED */ |
int last_flush; /* value of flush param for previous deflate call */ |
/* used by deflate.c: */ |
188,7 → 191,7 |
int nice_match; /* Stop searching when current match exceeds this */ |
/* used by trees.c: */ |
/* Didn't use ct_data typedef below to supress compiler warning */ |
/* 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 */ |
244,7 → 247,7 |
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 */ |
int last_eob_len; /* bit length of EOB code for last block */ |
uInt insert; /* bytes at end of window left to insert */ |
#ifdef DEBUG |
ulg compressed_len; /* total bit length of compressed file mod 2^32 */ |
294,6 → 297,7 |
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)); |
/programs/develop/libraries/zlib/gzguts.h |
---|
1,5 → 1,5 |
/* gzguts.h -- zlib internal header definitions for gz* operations |
* Copyright (C) 2004, 2005, 2010 Mark Adler |
* Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
12,7 → 12,7 |
# endif |
#endif |
#if ((__GNUC__-0) * 10 + __GNUC_MINOR__-0 >= 33) && !defined(NO_VIZ) |
#ifdef HAVE_HIDDEN |
# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) |
#else |
# define ZLIB_INTERNAL |
31,11 → 31,14 |
# define NO_GZCOMPRESS |
#endif |
#ifdef _MSC_VER |
# include <io.h> |
# define vsnprintf _vsnprintf |
#endif |
#define NO_vsnprintf |
/* unlike snprintf (which is required in C99, yet still not supported by |
Microsoft more than a decade later!), _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 */ |
#ifndef local |
# define local static |
#endif |
52,7 → 55,7 |
# include <windows.h> |
# define zstrerror() gz_strwinerror((DWORD)GetLastError()) |
#else |
# ifdef STDC |
# ifndef NO_STRERROR |
# include <errno.h> |
# define zstrerror() strerror(errno) |
# else |
68,7 → 71,15 |
ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); |
#endif |
/* default i/o buffer size -- double this for output when reading */ |
/* 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 */ |
84,23 → 95,25 |
/* 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 */ |
z_off64_t pos; /* current position in uncompressed data */ |
unsigned size; /* buffer size, zero if not allocated yet */ |
unsigned want; /* requested buffer size, default is GZBUFSIZE */ |
unsigned char *in; /* input buffer */ |
unsigned char *out; /* output buffer (double-sized when reading) */ |
unsigned char *next; /* next output data to deliver or write */ |
int direct; /* 0 if processing gzip, 1 if transparent */ |
/* just for reading */ |
unsigned have; /* amount of output data unused at next */ |
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 */ |
z_off64_t start; /* where the gzip data started, for rewinding */ |
z_off64_t raw; /* where the raw data started, for seeking */ |
int how; /* 0: get header, 1: copy, 2: decompress */ |
int direct; /* true if last read direct, false if gzip */ |
int past; /* true if read requested past end */ |
/* just for writing */ |
int level; /* compression level */ |
int strategy; /* compression strategy */ |
/programs/develop/libraries/zlib/gzlib.c |
---|
1,19 → 1,23 |
/* gzlib.c -- zlib functions common to reading and writing gzip files |
* Copyright (C) 2004, 2010 Mark Adler |
* Copyright (C) 2004, 2010, 2011, 2012, 2013 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 char *, int, const char *)); |
local gzFile gz_open OF((const void *, int, const char *)); |
#if defined UNDER_CE |
71,28 → 75,40 |
local void gz_reset(state) |
gz_statep state; |
{ |
state->x.have = 0; /* no output data available */ |
if (state->mode == GZ_READ) { /* for reading ... */ |
state->have = 0; /* no output data available */ |
state->eof = 0; /* not at end of file */ |
state->past = 0; /* have not read past end yet */ |
state->how = LOOK; /* look for gzip header */ |
state->direct = 1; /* default for empty file */ |
} |
state->seek = 0; /* no seek request pending */ |
gz_error(state, Z_OK, NULL); /* clear error */ |
state->pos = 0; /* no uncompressed data yet */ |
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 char *path; |
const void *path; |
int fd; |
const char *mode; |
{ |
gz_statep state; |
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 = malloc(sizeof(gz_state)); |
state = (gz_statep)malloc(sizeof(gz_state)); |
if (state == NULL) |
return NULL; |
state->size = 0; /* no buffers allocated yet */ |
103,6 → 119,7 |
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'; |
124,6 → 141,16 |
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; |
135,6 → 162,10 |
break; |
case 'F': |
state->strategy = Z_FIXED; |
break; |
case 'T': |
state->direct = 1; |
break; |
default: /* could consider as an error, but just ignore */ |
; |
} |
147,17 → 178,46 |
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 */ |
state->path = malloc(strlen(path) + 1); |
#ifdef _WIN32 |
if (fd == -2) { |
len = wcstombs(NULL, path, 0); |
if (len == (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 _WIN32 |
if (fd == -2) |
if (len) |
wcstombs(state->path, path, len + 1); |
else |
*(state->path) = 0; |
else |
#endif |
#if !defined(NO_snprintf) && !defined(NO_vsnprintf) |
snprintf(state->path, len + 1, "%s", (const char *)path); |
#else |
strcpy(state->path, path); |
#endif |
/* open the file with the appropriate mode (or just use fd) */ |
state->fd = fd != -1 ? fd : |
open(path, |
/* compute the flags for open() */ |
oflag = |
#ifdef O_LARGEFILE |
O_LARGEFILE | |
#endif |
164,13 → 224,25 |
#ifdef O_BINARY |
O_BINARY | |
#endif |
#ifdef O_CLOEXEC |
(cloexec ? O_CLOEXEC : 0) | |
#endif |
(state->mode == GZ_READ ? |
O_RDONLY : |
(O_WRONLY | O_CREAT | ( |
state->mode == GZ_WRITE ? |
(O_WRONLY | O_CREAT | |
#ifdef O_EXCL |
(exclusive ? O_EXCL : 0) | |
#endif |
(state->mode == GZ_WRITE ? |
O_TRUNC : |
O_APPEND))), |
0666); |
O_APPEND))); |
/* open the file with the appropriate flags (or just use fd) */ |
state->fd = fd > -1 ? fd : ( |
#ifdef _WIN32 |
fd == -2 ? _wopen(path, oflag, 0666) : |
#endif |
open((const char *)path, oflag, 0666)); |
if (state->fd == -1) { |
free(state->path); |
free(state); |
216,9 → 288,13 |
char *path; /* identifier for error messages */ |
gzFile gz; |
if (fd == -1 || (path = malloc(7 + 3 * sizeof(int))) == NULL) |
if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL) |
return NULL; |
#if !defined(NO_snprintf) && !defined(NO_vsnprintf) |
snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd); /* for debugging */ |
#else |
sprintf(path, "<fd:%d>", fd); /* for debugging */ |
#endif |
gz = gz_open(path, fd, mode); |
free(path); |
return gz; |
225,6 → 301,16 |
} |
/* -- see zlib.h -- */ |
#ifdef _WIN32 |
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; |
243,8 → 329,8 |
return -1; |
/* check and set requested size */ |
if (size == 0) |
return -1; |
if (size < 2) |
size = 2; /* need two bytes to check magic header */ |
state->want = size; |
return 0; |
} |
261,7 → 347,8 |
state = (gz_statep)file; |
/* check that we're reading and that there's no error */ |
if (state->mode != GZ_READ || state->err != Z_OK) |
if (state->mode != GZ_READ || |
(state->err != Z_OK && state->err != Z_BUF_ERROR)) |
return -1; |
/* back up and start over */ |
289,7 → 376,7 |
return -1; |
/* check that there's no error */ |
if (state->err != Z_OK) |
if (state->err != Z_OK && state->err != Z_BUF_ERROR) |
return -1; |
/* can only seek from start or relative to current position */ |
298,7 → 385,7 |
/* normalize offset to a SEEK_CUR specification */ |
if (whence == SEEK_SET) |
offset -= state->pos; |
offset -= state->x.pos; |
else if (state->seek) |
offset += state->skip; |
state->seek = 0; |
305,17 → 392,18 |
/* if within raw area while reading, just go there */ |
if (state->mode == GZ_READ && state->how == COPY && |
state->pos + offset >= state->raw) { |
ret = LSEEK(state->fd, offset - state->have, SEEK_CUR); |
state->x.pos + offset >= 0) { |
ret = LSEEK(state->fd, offset - state->x.have, SEEK_CUR); |
if (ret == -1) |
return -1; |
state->have = 0; |
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->pos += offset; |
return state->pos; |
state->x.pos += offset; |
return state->x.pos; |
} |
/* calculate skip amount, rewinding if needed for back seek when reading */ |
322,7 → 410,7 |
if (offset < 0) { |
if (state->mode != GZ_READ) /* writing -- can't go backwards */ |
return -1; |
offset += state->pos; |
offset += state->x.pos; |
if (offset < 0) /* before start of file! */ |
return -1; |
if (gzrewind(file) == -1) /* rewind, then skip to offset */ |
331,11 → 419,11 |
/* if reading, skip what's in output buffer (one less gzgetc() check) */ |
if (state->mode == GZ_READ) { |
n = GT_OFF(state->have) || (z_off64_t)state->have > offset ? |
(unsigned)offset : state->have; |
state->have -= n; |
state->next += n; |
state->pos += n; |
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; |
} |
344,7 → 432,7 |
state->seek = 1; |
state->skip = offset; |
} |
return state->pos + offset; |
return state->x.pos + offset; |
} |
/* -- see zlib.h -- */ |
373,7 → 461,7 |
return -1; |
/* return position */ |
return state->pos + (state->seek ? state->skip : 0); |
return state->x.pos + (state->seek ? state->skip : 0); |
} |
/* -- see zlib.h -- */ |
433,8 → 521,7 |
return 0; |
/* return end-of-file state */ |
return state->mode == GZ_READ ? |
(state->eof && state->strm.avail_in == 0 && state->have == 0) : 0; |
return state->mode == GZ_READ ? state->past : 0; |
} |
/* -- see zlib.h -- */ |
454,7 → 541,8 |
/* return error information */ |
if (errnum != NULL) |
*errnum = state->err; |
return state->msg == NULL ? "" : state->msg; |
return state->err == Z_MEM_ERROR ? "out of memory" : |
(state->msg == NULL ? "" : state->msg); |
} |
/* -- see zlib.h -- */ |
471,8 → 559,10 |
return; |
/* clear error and end-of-file */ |
if (state->mode == GZ_READ) |
if (state->mode == GZ_READ) { |
state->eof = 0; |
state->past = 0; |
} |
gz_error(state, Z_OK, NULL); |
} |
494,26 → 584,33 |
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, save as static string */ |
if (err == Z_MEM_ERROR) { |
state->msg = (char *)msg; |
/* 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 = malloc(strlen(state->path) + strlen(msg) + 3)) == NULL) { |
if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) == |
NULL) { |
state->err = Z_MEM_ERROR; |
state->msg = (char *)"out of memory"; |
return; |
} |
#if !defined(NO_snprintf) && !defined(NO_vsnprintf) |
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 |
return; |
} |
/programs/develop/libraries/zlib/gzread.c |
---|
1,5 → 1,5 |
/* gzread.c -- zlib functions for reading gzip files |
* Copyright (C) 2004, 2005, 2010 Mark Adler |
* Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
8,10 → 8,9 |
/* Local functions */ |
local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *)); |
local int gz_avail OF((gz_statep)); |
local int gz_next4 OF((gz_statep, unsigned long *)); |
local int gz_head OF((gz_statep)); |
local int gz_look OF((gz_statep)); |
local int gz_decomp OF((gz_statep)); |
local int gz_make OF((gz_statep)); |
local int gz_fetch OF((gz_statep)); |
local int gz_skip OF((gz_statep, z_off64_t)); |
/* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from |
46,73 → 45,54 |
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. |
gz_avail() assumes that strm->avail_in == 0. */ |
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) |
if (state->err != Z_OK && state->err != Z_BUF_ERROR) |
return -1; |
if (state->eof == 0) { |
if (gz_load(state, state->in, state->size, |
(unsigned *)&(strm->avail_in)) == -1) |
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; |
} |
/* Get next byte from input, or -1 if end or error. */ |
#define NEXT() ((strm->avail_in == 0 && gz_avail(state) == -1) ? -1 : \ |
(strm->avail_in == 0 ? -1 : \ |
(strm->avail_in--, *(strm->next_in)++))) |
/* Get a four-byte little-endian integer and return 0 on success and the value |
in *ret. Otherwise -1 is returned and *ret is not modified. */ |
local int gz_next4(state, ret) |
gz_statep state; |
unsigned long *ret; |
{ |
int ch; |
unsigned long val; |
z_streamp strm = &(state->strm); |
val = NEXT(); |
val += (unsigned)NEXT() << 8; |
val += (unsigned long)NEXT() << 16; |
ch = NEXT(); |
if (ch == -1) |
return -1; |
val += (unsigned long)ch << 24; |
*ret = val; |
return 0; |
} |
/* Look for gzip header, set up for inflate or copy. state->have must be zero. |
/* 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, and the gzip header will be skipped so |
that the next available input data is the raw deflate stream. 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 and the check value will be initialized. gz_head() will return 0 on |
success or -1 on failure. Failures may include read errors or gzip header |
errors. */ |
local int gz_head(state) |
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); |
int flags; |
unsigned len; |
/* allocate read buffers and inflate memory */ |
if (state->size == 0) { |
/* allocate buffers */ |
state->in = malloc(state->want); |
state->out = malloc(state->want << 1); |
state->in = (unsigned char *)malloc(state->want); |
state->out = (unsigned char *)malloc(state->want << 1); |
if (state->in == NULL || state->out == NULL) { |
if (state->out != NULL) |
free(state->out); |
129,7 → 109,7 |
state->strm.opaque = Z_NULL; |
state->strm.avail_in = 0; |
state->strm.next_in = Z_NULL; |
if (inflateInit2(&(state->strm), -15) != Z_OK) { /* raw inflate */ |
if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) { /* gunzip */ |
free(state->out); |
free(state->in); |
state->size = 0; |
138,8 → 118,8 |
} |
} |
/* get some data in the input buffer */ |
if (strm->avail_in == 0) { |
/* 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) |
146,75 → 126,37 |
return 0; |
} |
/* look for the gzip magic header bytes 31 and 139 */ |
if (strm->next_in[0] == 31) { |
strm->avail_in--; |
strm->next_in++; |
if (strm->avail_in == 0 && gz_avail(state) == -1) |
return -1; |
if (strm->avail_in && strm->next_in[0] == 139) { |
/* we have a gzip header, woo hoo! */ |
strm->avail_in--; |
strm->next_in++; |
/* skip rest of header */ |
if (NEXT() != 8) { /* compression method */ |
gz_error(state, Z_DATA_ERROR, "unknown compression method"); |
return -1; |
} |
flags = NEXT(); |
if (flags & 0xe0) { /* reserved flag bits */ |
gz_error(state, Z_DATA_ERROR, "unknown header flags set"); |
return -1; |
} |
NEXT(); /* modification time */ |
NEXT(); |
NEXT(); |
NEXT(); |
NEXT(); /* extra flags */ |
NEXT(); /* operating system */ |
if (flags & 4) { /* extra field */ |
len = (unsigned)NEXT(); |
len += (unsigned)NEXT() << 8; |
while (len--) |
if (NEXT() < 0) |
break; |
} |
if (flags & 8) /* file name */ |
while (NEXT() > 0) |
; |
if (flags & 16) /* comment */ |
while (NEXT() > 0) |
; |
if (flags & 2) { /* header crc */ |
NEXT(); |
NEXT(); |
} |
/* an unexpected end of file is not checked for here -- it will be |
noticed on the first request for uncompressed data */ |
/* set up for decompression */ |
/* 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); |
strm->adler = crc32(0L, Z_NULL, 0); |
state->how = GZIP; |
state->direct = 0; |
return 0; |
} |
else { |
/* not a gzip file -- save first byte (31) and fall to raw i/o */ |
state->out[0] = 31; |
state->have = 1; |
/* 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, save start of raw data for seeking, 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->raw = state->pos; |
state->next = state->out; |
/* 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->next + state->have, strm->next_in, strm->avail_in); |
state->have += 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; |
223,19 → 165,15 |
} |
/* Decompress from input to the provided next_out and avail_out in the state. |
If the end of the compressed data is reached, then verify the gzip trailer |
check value and length (modulo 2^32). state->have and state->next are set |
to point to the just decompressed data, and the crc is updated. If the |
trailer is verified, state->how is reset to LOOK to look for the next gzip |
stream or raw data, once state->have is depleted. Returns 0 on success, -1 |
on failure. Failures may include invalid compressed data or a failed gzip |
trailer verification. */ |
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; |
int ret = Z_OK; |
unsigned had; |
unsigned long crc, len; |
z_streamp strm = &(state->strm); |
/* fill output buffer up to end of deflate stream */ |
245,8 → 183,8 |
if (strm->avail_in == 0 && gz_avail(state) == -1) |
return -1; |
if (strm->avail_in == 0) { |
gz_error(state, Z_DATA_ERROR, "unexpected end of file"); |
return -1; |
gz_error(state, Z_BUF_ERROR, "unexpected end of file"); |
break; |
} |
/* decompress and handle errors */ |
267,62 → 205,50 |
} |
} while (strm->avail_out && ret != Z_STREAM_END); |
/* update available output and crc check value */ |
state->have = had - strm->avail_out; |
state->next = strm->next_out - state->have; |
strm->adler = crc32(strm->adler, state->next, state->have); |
/* update available output */ |
state->x.have = had - strm->avail_out; |
state->x.next = strm->next_out - state->x.have; |
/* check gzip trailer if at end of deflate stream */ |
if (ret == Z_STREAM_END) { |
if (gz_next4(state, &crc) == -1 || gz_next4(state, &len) == -1) { |
gz_error(state, Z_DATA_ERROR, "unexpected end of file"); |
return -1; |
} |
if (crc != strm->adler) { |
gz_error(state, Z_DATA_ERROR, "incorrect data check"); |
return -1; |
} |
if (len != (strm->total_out & 0xffffffffL)) { |
gz_error(state, Z_DATA_ERROR, "incorrect length check"); |
return -1; |
} |
state->how = LOOK; /* ready for next stream, once have is 0 (leave |
state->direct unchanged to remember how) */ |
} |
/* if the gzip stream completed successfully, look for another */ |
if (ret == Z_STREAM_END) |
state->how = LOOK; |
/* good decompression */ |
return 0; |
} |
/* Make data and put in the output buffer. Assumes that state->have == 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 (and skipped if found) to determine wither to copy or decompress. |
Returns -1 on error, otherwise 0. gz_make() will leave state->have as COPY |
or GZIP unless the end of the input file has been reached and all data has |
been processed. */ |
local int gz_make(state) |
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); |
if (state->how == LOOK) { /* look for gzip header */ |
if (gz_head(state) == -1) |
do { |
switch(state->how) { |
case LOOK: /* -> LOOK, COPY (only if never GZIP), or GZIP */ |
if (gz_look(state) == -1) |
return -1; |
if (state->have) /* got some data from gz_head() */ |
if (state->how == LOOK) |
return 0; |
} |
if (state->how == COPY) { /* straight copy */ |
if (gz_load(state, state->out, state->size << 1, &(state->have)) == -1) |
break; |
case COPY: /* -> COPY */ |
if (gz_load(state, state->out, state->size << 1, &(state->x.have)) |
== -1) |
return -1; |
state->next = state->out; |
} |
else if (state->how == GZIP) { /* decompress */ |
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; |
} |
336,12 → 262,12 |
/* skip over len bytes or reach end-of-file, whichever comes first */ |
while (len) |
/* skip over whatever is in output buffer */ |
if (state->have) { |
n = GT_OFF(state->have) || (z_off64_t)state->have > len ? |
(unsigned)len : state->have; |
state->have -= n; |
state->next += n; |
state->pos += n; |
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; |
} |
352,7 → 278,7 |
/* need more data to skip -- load up output buffer */ |
else { |
/* get more output, looking for header if required */ |
if (gz_make(state) == -1) |
if (gz_fetch(state) == -1) |
return -1; |
} |
return 0; |
374,14 → 300,15 |
state = (gz_statep)file; |
strm = &(state->strm); |
/* check that we're reading and that there's no error */ |
if (state->mode != GZ_READ || state->err != Z_OK) |
/* 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 the flaw in the interface) */ |
if ((int)len < 0) { |
gz_error(state, Z_BUF_ERROR, "requested length does not fit in int"); |
gz_error(state, Z_DATA_ERROR, "requested length does not fit in int"); |
return -1; |
} |
400,24 → 327,26 |
got = 0; |
do { |
/* first just try copying data from the output buffer */ |
if (state->have) { |
n = state->have > len ? len : state->have; |
memcpy(buf, state->next, n); |
state->next += n; |
state->have -= n; |
if (state->x.have) { |
n = state->x.have > len ? len : 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 && strm->avail_in == 0) |
else if (state->eof && 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 || len < (state->size << 1)) { |
/* get more output, looking for header if required */ |
if (gz_make(state) == -1) |
if (gz_fetch(state) == -1) |
return -1; |
continue; /* no progress yet -- go back to memcpy() above */ |
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 */ |
} |
424,7 → 353,7 |
/* large len -- read directly into user buffer */ |
else if (state->how == COPY) { /* read directly */ |
if (gz_load(state, buf, len, &n) == -1) |
if (gz_load(state, (unsigned char *)buf, len, &n) == -1) |
return -1; |
} |
431,11 → 360,11 |
/* large len -- decompress directly into user buffer */ |
else { /* state->how == GZIP */ |
strm->avail_out = len; |
strm->next_out = buf; |
strm->next_out = (unsigned char *)buf; |
if (gz_decomp(state) == -1) |
return -1; |
n = state->have; |
state->have = 0; |
n = state->x.have; |
state->x.have = 0; |
} |
/* update progress */ |
442,7 → 371,7 |
len -= n; |
buf = (char *)buf + n; |
got += n; |
state->pos += n; |
state->x.pos += n; |
} while (len); |
/* return number of bytes read into user buffer (will fit in int) */ |
450,6 → 379,11 |
} |
/* -- see zlib.h -- */ |
#ifdef Z_PREFIX_SET |
# undef z_gzgetc |
#else |
# undef gzgetc |
#endif |
int ZEXPORT gzgetc(file) |
gzFile file; |
{ |
462,15 → 396,16 |
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) |
/* 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->have) { |
state->have--; |
state->pos++; |
return *(state->next)++; |
if (state->x.have) { |
state->x.have--; |
state->x.pos++; |
return *(state->x.next)++; |
} |
/* nothing there -- try gzread() */ |
478,6 → 413,12 |
return ret < 1 ? -1 : buf[0]; |
} |
int ZEXPORT gzgetc_(file) |
gzFile file; |
{ |
return gzgetc(file); |
} |
/* -- see zlib.h -- */ |
int ZEXPORT gzungetc(c, file) |
int c; |
490,8 → 431,9 |
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) |
/* 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 */ |
506,32 → 448,34 |
return -1; |
/* if output buffer empty, put byte at end (allows more pushing) */ |
if (state->have == 0) { |
state->have = 1; |
state->next = state->out + (state->size << 1) - 1; |
state->next[0] = c; |
state->pos--; |
if (state->x.have == 0) { |
state->x.have = 1; |
state->x.next = state->out + (state->size << 1) - 1; |
state->x.next[0] = c; |
state->x.pos--; |
state->past = 0; |
return c; |
} |
/* if no room, give up (must have already done a gzungetc()) */ |
if (state->have == (state->size << 1)) { |
gz_error(state, Z_BUF_ERROR, "out of room to push characters"); |
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->next == state->out) { |
unsigned char *src = state->out + state->have; |
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->next = dest; |
state->x.next = dest; |
} |
state->have++; |
state->next--; |
state->next[0] = c; |
state->pos--; |
state->x.have++; |
state->x.next--; |
state->x.next[0] = c; |
state->x.pos--; |
state->past = 0; |
return c; |
} |
551,8 → 495,9 |
return NULL; |
state = (gz_statep)file; |
/* check that we're reading and that there's no error */ |
if (state->mode != GZ_READ || state->err != Z_OK) |
/* 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 */ |
569,32 → 514,31 |
left = (unsigned)len - 1; |
if (left) do { |
/* assure that something is in the output buffer */ |
if (state->have == 0) { |
if (gz_make(state) == -1) |
if (state->x.have == 0 && gz_fetch(state) == -1) |
return NULL; /* error */ |
if (state->have == 0) { /* end of file */ |
if (buf == str) /* got bupkus */ |
return NULL; |
break; /* got something -- return it */ |
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->have > left ? left : state->have; |
eol = memchr(state->next, '\n', n); |
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->next) + 1; |
n = (unsigned)(eol - state->x.next) + 1; |
/* copy through end-of-line, or remainder if not found */ |
memcpy(buf, state->next, n); |
state->have -= n; |
state->next += n; |
state->pos += n; |
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); |
/* found end-of-line or out of space -- terminate string and return it */ |
/* return terminated string, or if nothing, end of file */ |
if (buf == str) |
return NULL; |
buf[0] = 0; |
return str; |
} |
610,16 → 554,12 |
return 0; |
state = (gz_statep)file; |
/* check that we're reading */ |
if (state->mode != GZ_READ) |
return 0; |
/* 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->how == LOOK && state->have == 0) |
(void)gz_head(state); |
if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0) |
(void)gz_look(state); |
/* return 1 if reading direct, 0 if decompressing a gzip stream */ |
/* return 1 if transparent, 0 if processing a gzip stream */ |
return state->direct; |
} |
627,7 → 567,7 |
int ZEXPORT gzclose_r(file) |
gzFile file; |
{ |
int ret; |
int ret, err; |
gz_statep state; |
/* get internal structure */ |
645,9 → 585,10 |
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 : Z_OK; |
return ret ? Z_ERRNO : err; |
} |
/programs/develop/libraries/zlib/gzwrite.c |
---|
1,5 → 1,5 |
/* gzwrite.c -- zlib functions for writing gzip files |
* Copyright (C) 2004, 2005, 2010 Mark Adler |
* Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
18,13 → 18,18 |
int ret; |
z_streamp strm = &(state->strm); |
/* allocate input and output buffers */ |
state->in = malloc(state->want); |
state->out = malloc(state->want); |
if (state->in == NULL || state->out == NULL) { |
if (state->out != NULL) |
free(state->out); |
if (state->in != NULL) |
/* allocate input buffer */ |
state->in = (unsigned char *)malloc(state->want); |
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; |
35,20 → 40,24 |
strm->zfree = Z_NULL; |
strm->opaque = Z_NULL; |
ret = deflateInit2(strm, state->level, Z_DEFLATED, |
15 + 16, 8, state->strategy); |
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; |
} |
} |
/* mark state as initialized */ |
state->size = state->want; |
/* initialize write buffer */ |
/* initialize write buffer if compressing */ |
if (!state->direct) { |
strm->avail_out = state->size; |
strm->next_out = state->out; |
state->next = strm->next_out; |
state->x.next = strm->next_out; |
} |
return 0; |
} |
55,7 → 64,9 |
/* 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, 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. */ |
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; |
68,6 → 79,17 |
if (state->size == 0 && gz_init(state) == -1) |
return -1; |
/* write directly if requested */ |
if (state->direct) { |
got = write(state->fd, strm->next_in, strm->avail_in); |
if (got < 0 || (unsigned)got != strm->avail_in) { |
gz_error(state, Z_ERRNO, zstrerror()); |
return -1; |
} |
strm->avail_in = 0; |
return 0; |
} |
/* run deflate() on provided input until it produces no more output */ |
ret = Z_OK; |
do { |
75,8 → 97,8 |
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))) { |
have = (unsigned)(strm->next_out - state->next); |
if (have && ((got = write(state->fd, state->next, have)) < 0 || |
have = (unsigned)(strm->next_out - state->x.next); |
if (have && ((got = write(state->fd, state->x.next, have)) < 0 || |
(unsigned)got != have)) { |
gz_error(state, Z_ERRNO, zstrerror()); |
return -1; |
85,7 → 107,7 |
strm->avail_out = state->size; |
strm->next_out = state->out; |
} |
state->next = strm->next_out; |
state->x.next = strm->next_out; |
} |
/* compress */ |
131,7 → 153,7 |
} |
strm->avail_in = n; |
strm->next_in = state->in; |
state->pos += n; |
state->x.pos += n; |
if (gz_comp(state, Z_NO_FLUSH) == -1) |
return -1; |
len -= n; |
146,7 → 168,6 |
unsigned len; |
{ |
unsigned put = len; |
unsigned n; |
gz_statep state; |
z_streamp strm; |
163,7 → 184,7 |
/* since an int is returned, make sure len fits in one, otherwise return |
with an error (this avoids the flaw in the interface) */ |
if ((int)len < 0) { |
gz_error(state, Z_BUF_ERROR, "requested length does not fit in int"); |
gz_error(state, Z_DATA_ERROR, "requested length does not fit in int"); |
return 0; |
} |
186,16 → 207,19 |
if (len < state->size) { |
/* copy to input buffer, compress when full */ |
do { |
unsigned have, copy; |
if (strm->avail_in == 0) |
strm->next_in = state->in; |
n = state->size - strm->avail_in; |
if (n > len) |
n = len; |
memcpy(strm->next_in + strm->avail_in, buf, n); |
strm->avail_in += n; |
state->pos += n; |
buf = (char *)buf + n; |
len -= n; |
have = (unsigned)((strm->next_in + strm->avail_in) - state->in); |
copy = state->size - have; |
if (copy > len) |
copy = len; |
memcpy(state->in + have, buf, copy); |
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); |
207,8 → 231,8 |
/* directly compress user buffer to file */ |
strm->avail_in = len; |
strm->next_in = (voidp)buf; |
state->pos += len; |
strm->next_in = (z_const Bytef *)buf; |
state->x.pos += len; |
if (gz_comp(state, Z_NO_FLUSH) == -1) |
return 0; |
} |
222,6 → 246,7 |
gzFile file; |
int c; |
{ |
unsigned have; |
unsigned char buf[1]; |
gz_statep state; |
z_streamp strm; |
245,19 → 270,23 |
/* try writing to input buffer for speed (state->size == 0 if buffer not |
initialized) */ |
if (strm->avail_in < state->size) { |
if (state->size) { |
if (strm->avail_in == 0) |
strm->next_in = state->in; |
strm->next_in[strm->avail_in++] = c; |
state->pos++; |
return c; |
have = (unsigned)((strm->next_in + strm->avail_in) - state->in); |
if (have < state->size) { |
state->in[have] = c; |
strm->avail_in++; |
state->x.pos++; |
return c & 0xff; |
} |
} |
/* no room in buffer or not initialized, use gz_write() */ |
buf[0] = c; |
if (gzwrite(file, buf, 1) != 1) |
return -1; |
return c; |
return c & 0xff; |
} |
/* -- see zlib.h -- */ |
274,16 → 303,15 |
return ret == 0 && len != 0 ? -1 : ret; |
} |
#ifdef STDC |
#if defined(STDC) || defined(Z_HAVE_STDARG_H) |
#include <stdarg.h> |
/* -- see zlib.h -- */ |
int ZEXPORTVA gzprintf (gzFile file, const char *format, ...) |
int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va) |
{ |
int size, len; |
gz_statep state; |
z_streamp strm; |
va_list va; |
/* get internal structure */ |
if (file == NULL) |
313,25 → 341,20 |
/* do the printf() into the input buffer, put length in len */ |
size = (int)(state->size); |
state->in[size - 1] = 0; |
va_start(va, format); |
#ifdef NO_vsnprintf |
# ifdef HAS_vsprintf_void |
(void)vsprintf(state->in, format, va); |
va_end(va); |
(void)vsprintf((char *)(state->in), format, va); |
for (len = 0; len < size; len++) |
if (state->in[len] == 0) break; |
# else |
len = vsprintf(state->in, format, va); |
va_end(va); |
len = vsprintf((char *)(state->in), format, va); |
# endif |
#else |
# ifdef HAS_vsnprintf_void |
(void)vsnprintf(state->in, size, format, va); |
va_end(va); |
len = strlen(state->in); |
(void)vsnprintf((char *)(state->in), size, format, va); |
len = strlen((char *)(state->in)); |
# else |
len = vsnprintf((char *)(state->in), size, format, va); |
va_end(va); |
# endif |
#endif |
342,12 → 365,23 |
/* update buffer and position, defer compression until needed */ |
strm->avail_in = (unsigned)len; |
strm->next_in = state->in; |
state->pos += len; |
state->x.pos += len; |
return len; |
} |
#else /* !STDC */ |
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) |
366,6 → 400,10 |
state = (gz_statep)file; |
strm = &(state->strm); |
/* check that can really pass pointer in ints */ |
if (sizeof(int) != sizeof(void *)) |
return 0; |
/* check that we're writing and that there's no error */ |
if (state->mode != GZ_WRITE || state->err != Z_OK) |
return 0; |
390,22 → 428,23 |
state->in[size - 1] = 0; |
#ifdef NO_snprintf |
# ifdef HAS_sprintf_void |
sprintf(state->in, format, a1, a2, a3, a4, a5, a6, a7, a8, |
sprintf((char *)(state->in), 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 (state->in[len] == 0) break; |
# else |
len = sprintf(state->in, format, a1, a2, a3, a4, a5, a6, a7, a8, |
len = sprintf((char *)(state->in), 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(state->in, size, format, a1, a2, a3, a4, a5, a6, a7, a8, |
snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6, a7, a8, |
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); |
len = strlen(state->in); |
len = strlen((char *)(state->in)); |
# else |
len = snprintf(state->in, size, format, a1, a2, a3, a4, a5, a6, a7, a8, |
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20); |
len = snprintf((char *)(state->in), size, format, a1, a2, a3, a4, a5, a6, |
a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, |
a19, a20); |
# endif |
#endif |
416,7 → 455,7 |
/* update buffer and position, defer compression until needed */ |
strm->avail_in = (unsigned)len; |
strm->next_in = state->in; |
state->pos += len; |
state->x.pos += len; |
return len; |
} |
500,7 → 539,7 |
int ZEXPORT gzclose_w(file) |
gzFile file; |
{ |
int ret = 0; |
int ret = Z_OK; |
gz_statep state; |
/* get internal structure */ |
515,17 → 554,24 |
/* check for seek request */ |
if (state->seek) { |
state->seek = 0; |
ret += gz_zero(state, state->skip); |
if (gz_zero(state, state->skip) == -1) |
ret = state->err; |
} |
/* flush, free memory, and close file */ |
ret += gz_comp(state, Z_FINISH); |
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); |
ret += close(state->fd); |
if (close(state->fd) == -1) |
ret = Z_ERRNO; |
free(state); |
return ret ? Z_ERRNO : Z_OK; |
return ret; |
} |
/programs/develop/libraries/zlib/infback.c |
---|
1,5 → 1,5 |
/* infback.c -- inflate using a call-back interface |
* Copyright (C) 1995-2009 Mark Adler |
* Copyright (C) 1995-2011 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
42,10 → 42,19 |
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) strm->zfree = zcfree; |
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; |
246,7 → 255,7 |
void FAR *out_desc; |
{ |
struct inflate_state FAR *state; |
unsigned char FAR *next; /* next input */ |
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 */ |
394,7 → 403,6 |
PULLBYTE(); |
} |
if (here.val < 16) { |
NEEDBITS(here.bits); |
DROPBITS(here.bits); |
state->lens[state->have++] = here.val; |
} |
/programs/develop/libraries/zlib/inffast.c |
---|
1,5 → 1,5 |
/* inffast.c -- fast decoding |
* Copyright (C) 1995-2008, 2010 Mark Adler |
* Copyright (C) 1995-2008, 2010, 2013 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
69,8 → 69,8 |
unsigned start; /* inflate()'s starting value for strm->avail_out */ |
{ |
struct inflate_state FAR *state; |
unsigned char FAR *in; /* local strm->next_in */ |
unsigned char FAR *last; /* while in < last, enough input available */ |
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 */ |
/programs/develop/libraries/zlib/inffixed.h |
---|
2,9 → 2,9 |
* Generated automatically by makefixed(). |
*/ |
/* 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. |
/* 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] = { |
/programs/develop/libraries/zlib/inflate.c |
---|
1,5 → 1,5 |
/* inflate.c -- zlib decompression |
* Copyright (C) 1995-2010 Mark Adler |
* Copyright (C) 1995-2012 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
93,14 → 93,15 |
/* function prototypes */ |
local void fixedtables OF((struct inflate_state FAR *state)); |
local int updatewindow OF((z_streamp strm, unsigned out)); |
local int updatewindow OF((z_streamp strm, const unsigned char FAR *end, |
unsigned copy)); |
#ifdef BUILDFIXED |
void makefixed OF((void)); |
#endif |
local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf, |
local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf, |
unsigned len)); |
int ZEXPORT inflateReset(strm) |
int ZEXPORT inflateResetKeep(strm) |
z_streamp strm; |
{ |
struct inflate_state FAR *state; |
109,15 → 110,13 |
state = (struct inflate_state FAR *)strm->state; |
strm->total_in = strm->total_out = state->total = 0; |
strm->msg = Z_NULL; |
strm->adler = 1; /* to support ill-conceived Java test suite */ |
if (state->wrap) /* to support ill-conceived Java test suite */ |
strm->adler = state->wrap & 1; |
state->mode = HEAD; |
state->last = 0; |
state->havedict = 0; |
state->dmax = 32768U; |
state->head = Z_NULL; |
state->wsize = 0; |
state->whave = 0; |
state->wnext = 0; |
state->hold = 0; |
state->bits = 0; |
state->lencode = state->distcode = state->next = state->codes; |
127,6 → 126,19 |
return Z_OK; |
} |
int ZEXPORT inflateReset(strm) |
z_streamp strm; |
{ |
struct inflate_state FAR *state; |
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
state = (struct inflate_state FAR *)strm->state; |
state->wsize = 0; |
state->whave = 0; |
state->wnext = 0; |
return inflateResetKeep(strm); |
} |
int ZEXPORT inflateReset2(strm, windowBits) |
z_streamp strm; |
int windowBits; |
180,10 → 192,19 |
if (strm == Z_NULL) 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) strm->zfree = zcfree; |
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; |
321,8 → 342,8 |
low = 0; |
for (;;) { |
if ((low % 7) == 0) printf("\n "); |
printf("{%u,%u,%d}", state.lencode[low].op, state.lencode[low].bits, |
state.lencode[low].val); |
printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op, |
state.lencode[low].bits, state.lencode[low].val); |
if (++low == size) break; |
putchar(','); |
} |
355,12 → 376,13 |
output will fall in the output data, making match copies simpler and faster. |
The advantage may be dependent on the size of the processor's data caches. |
*/ |
local int updatewindow(strm, out) |
local int updatewindow(strm, end, copy) |
z_streamp strm; |
unsigned out; |
const Bytef *end; |
unsigned copy; |
{ |
struct inflate_state FAR *state; |
unsigned copy, dist; |
unsigned dist; |
state = (struct inflate_state FAR *)strm->state; |
380,9 → 402,8 |
} |
/* copy state->wsize or less output bytes into the circular window */ |
copy = out - strm->avail_out; |
if (copy >= state->wsize) { |
zmemcpy(state->window, strm->next_out - state->wsize, state->wsize); |
zmemcpy(state->window, end - state->wsize, state->wsize); |
state->wnext = 0; |
state->whave = state->wsize; |
} |
389,10 → 410,10 |
else { |
dist = state->wsize - state->wnext; |
if (dist > copy) dist = copy; |
zmemcpy(state->window + state->wnext, strm->next_out - copy, dist); |
zmemcpy(state->window + state->wnext, end - copy, dist); |
copy -= dist; |
if (copy) { |
zmemcpy(state->window, strm->next_out - copy, copy); |
zmemcpy(state->window, end - copy, copy); |
state->wnext = copy; |
state->whave = state->wsize; |
} |
499,11 → 520,6 |
bits -= bits & 7; \ |
} while (0) |
/* Reverse the bytes in a 32-bit value */ |
#define REVERSE(q) \ |
((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ |
(((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) |
/* |
inflate() uses a state machine to process as much input data and generate as |
much output data as possible before returning. The state machine is |
591,7 → 607,7 |
int flush; |
{ |
struct inflate_state FAR *state; |
unsigned char FAR *next; /* next input */ |
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 */ |
797,7 → 813,7 |
#endif |
case DICTID: |
NEEDBITS(32); |
strm->adler = state->check = REVERSE(hold); |
strm->adler = state->check = ZSWAP32(hold); |
INITBITS(); |
state->mode = DICT; |
case DICT: |
905,7 → 921,7 |
while (state->have < 19) |
state->lens[order[state->have++]] = 0; |
state->next = state->codes; |
state->lencode = (code const FAR *)(state->next); |
state->lencode = (const code FAR *)(state->next); |
state->lenbits = 7; |
ret = inflate_table(CODES, state->lens, 19, &(state->next), |
&(state->lenbits), state->work); |
925,7 → 941,6 |
PULLBYTE(); |
} |
if (here.val < 16) { |
NEEDBITS(here.bits); |
DROPBITS(here.bits); |
state->lens[state->have++] = here.val; |
} |
980,7 → 995,7 |
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->lencode = (const code FAR *)(state->next); |
state->lenbits = 9; |
ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), |
&(state->lenbits), state->work); |
989,7 → 1004,7 |
state->mode = BAD; |
break; |
} |
state->distcode = (code const FAR *)(state->next); |
state->distcode = (const code FAR *)(state->next); |
state->distbits = 6; |
ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, |
&(state->next), &(state->distbits), state->work); |
1170,7 → 1185,7 |
#ifdef GUNZIP |
state->flags ? hold : |
#endif |
REVERSE(hold)) != state->check) { |
ZSWAP32(hold)) != state->check) { |
strm->msg = (char *)"incorrect data check"; |
state->mode = BAD; |
break; |
1214,8 → 1229,9 |
*/ |
inf_leave: |
RESTORE(); |
if (state->wsize || (state->mode < CHECK && out != strm->avail_out)) |
if (updatewindow(strm, out)) { |
if (state->wsize || (out != strm->avail_out && state->mode < BAD && |
(state->mode < CHECK || flush != Z_FINISH))) |
if (updatewindow(strm, strm->next_out, out - strm->avail_out)) { |
state->mode = MEM; |
return Z_MEM_ERROR; |
} |
1249,6 → 1265,29 |
return Z_OK; |
} |
int ZEXPORT inflateGetDictionary(strm, dictionary, dictLength) |
z_streamp strm; |
Bytef *dictionary; |
uInt *dictLength; |
{ |
struct inflate_state FAR *state; |
/* check state */ |
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
state = (struct inflate_state FAR *)strm->state; |
/* copy dictionary */ |
if (state->whave && dictionary != Z_NULL) { |
zmemcpy(dictionary, state->window + state->wnext, |
state->whave - state->wnext); |
zmemcpy(dictionary + state->whave - state->wnext, |
state->window, state->wnext); |
} |
if (dictLength != Z_NULL) |
*dictLength = state->whave; |
return Z_OK; |
} |
int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) |
z_streamp strm; |
const Bytef *dictionary; |
1255,7 → 1294,8 |
uInt dictLength; |
{ |
struct inflate_state FAR *state; |
unsigned long id; |
unsigned long dictid; |
int ret; |
/* check state */ |
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
1263,29 → 1303,21 |
if (state->wrap != 0 && state->mode != DICT) |
return Z_STREAM_ERROR; |
/* check for correct dictionary id */ |
/* check for correct dictionary identifier */ |
if (state->mode == DICT) { |
id = adler32(0L, Z_NULL, 0); |
id = adler32(id, dictionary, dictLength); |
if (id != state->check) |
dictid = adler32(0L, Z_NULL, 0); |
dictid = adler32(dictid, dictionary, dictLength); |
if (dictid != state->check) |
return Z_DATA_ERROR; |
} |
/* copy dictionary to window */ |
if (updatewindow(strm, strm->avail_out)) { |
/* copy dictionary to window using updatewindow(), which will amend the |
existing dictionary if appropriate */ |
ret = updatewindow(strm, dictionary + dictLength, dictLength); |
if (ret) { |
state->mode = MEM; |
return Z_MEM_ERROR; |
} |
if (dictLength > state->wsize) { |
zmemcpy(state->window, dictionary + dictLength - state->wsize, |
state->wsize); |
state->whave = state->wsize; |
} |
else { |
zmemcpy(state->window + state->wsize - dictLength, dictionary, |
dictLength); |
state->whave = dictLength; |
} |
state->havedict = 1; |
Tracev((stderr, "inflate: dictionary set\n")); |
return Z_OK; |
1321,7 → 1353,7 |
*/ |
local unsigned syncsearch(have, buf, len) |
unsigned FAR *have; |
unsigned char FAR *buf; |
const unsigned char FAR *buf; |
unsigned len; |
{ |
unsigned got; |
1433,8 → 1465,8 |
} |
/* copy state */ |
zmemcpy(dest, source, sizeof(z_stream)); |
zmemcpy(copy, state, sizeof(struct inflate_state)); |
zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); |
zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state)); |
if (state->lencode >= state->codes && |
state->lencode <= state->codes + ENOUGH - 1) { |
copy->lencode = copy->codes + (state->lencode - state->codes); |
/programs/develop/libraries/zlib/inftrees.c |
---|
1,5 → 1,5 |
/* inftrees.c -- generate Huffman trees for efficient decoding |
* Copyright (C) 1995-2010 Mark Adler |
* Copyright (C) 1995-2013 Mark Adler |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
9,7 → 9,7 |
#define MAXBITS 15 |
const char inflate_copyright[] = |
" inflate 1.2.5 Copyright 1995-2010 Mark Adler "; |
" inflate 1.2.8 Copyright 1995-2013 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 |
62,7 → 62,7 |
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, 73, 195}; |
19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78}; |
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, |
208,8 → 208,8 |
mask = used - 1; /* mask for comparing low */ |
/* check available table space */ |
if ((type == LENS && used >= ENOUGH_LENS) || |
(type == DISTS && used >= ENOUGH_DISTS)) |
if ((type == LENS && used > ENOUGH_LENS) || |
(type == DISTS && used > ENOUGH_DISTS)) |
return 1; |
/* process all codes and make table entries */ |
277,8 → 277,8 |
/* check for enough space */ |
used += 1U << curr; |
if ((type == LENS && used >= ENOUGH_LENS) || |
(type == DISTS && used >= ENOUGH_DISTS)) |
if ((type == LENS && used > ENOUGH_LENS) || |
(type == DISTS && used > ENOUGH_DISTS)) |
return 1; |
/* point entry in root table to sub-table */ |
289,40 → 289,16 |
} |
} |
/* |
Fill in rest of table for incomplete codes. This loop is similar to the |
loop above in incrementing huff for table indices. It is assumed that |
len is equal to curr + drop, so there is no loop needed to increment |
through high index bits. When the current sub-table is filled, the loop |
drops back to the root table to fill in any remaining entries there. |
*/ |
/* 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; |
while (huff != 0) { |
/* when done with sub-table, drop back to root table */ |
if (drop != 0 && (huff & mask) != low) { |
drop = 0; |
len = root; |
next = *table; |
here.bits = (unsigned char)len; |
next[huff] = here; |
} |
/* put invalid code marker in table */ |
next[huff >> drop] = here; |
/* backwards increment the len-bit code huff */ |
incr = 1U << (len - 1); |
while (huff & incr) |
incr >>= 1; |
if (incr != 0) { |
huff &= incr - 1; |
huff += incr; |
} |
else |
huff = 0; |
} |
/* set return parameters */ |
*table += used; |
*bits = root; |
/programs/develop/libraries/zlib/trees.c |
---|
1,5 → 1,5 |
/* trees.c -- output deflated data using Huffman coding |
* Copyright (C) 1995-2010 Jean-loup Gailly |
* Copyright (C) 1995-2012 Jean-loup Gailly |
* detect_data_type() function provided freely by Cosmin Truta, 2006 |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
74,11 → 74,6 |
* probability, to avoid transmitting the lengths for unused bit length codes. |
*/ |
#define Buf_size (8 * 2*sizeof(char)) |
/* Number of bits used within bi_buf. (bi_buf might be implemented on |
* more than 16 bits on some systems.) |
*/ |
/* =========================================================================== |
* Local data. These are initialized only once. |
*/ |
151,8 → 146,8 |
local int build_bl_tree OF((deflate_state *s)); |
local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, |
int blcodes)); |
local void compress_block OF((deflate_state *s, ct_data *ltree, |
ct_data *dtree)); |
local void compress_block OF((deflate_state *s, const ct_data *ltree, |
const ct_data *dtree)); |
local int detect_data_type OF((deflate_state *s)); |
local unsigned bi_reverse OF((unsigned value, int length)); |
local void bi_windup OF((deflate_state *s)); |
399,7 → 394,6 |
s->bi_buf = 0; |
s->bi_valid = 0; |
s->last_eob_len = 8; /* enough lookahead for inflate */ |
#ifdef DEBUG |
s->compressed_len = 0L; |
s->bits_sent = 0L; |
883,15 → 877,17 |
} |
/* =========================================================================== |
* Flush the bits in the bit buffer to pending output (leaves at most 7 bits) |
*/ |
void ZLIB_INTERNAL _tr_flush_bits(s) |
deflate_state *s; |
{ |
bi_flush(s); |
} |
/* =========================================================================== |
* Send one empty static block to give enough lookahead for inflate. |
* This takes 10 bits, of which 7 may remain in the bit buffer. |
* The current inflate code requires 9 bits of lookahead. If the |
* last two codes for the previous block (real code plus EOB) were coded |
* on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode |
* the last real code. In this case we send two empty static blocks instead |
* of one. (There are no problems if the previous block is stored or fixed.) |
* To simplify the code, we assume the worst case of last real code encoded |
* on one bit only. |
*/ |
void ZLIB_INTERNAL _tr_align(s) |
deflate_state *s; |
902,21 → 898,7 |
s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ |
#endif |
bi_flush(s); |
/* Of the 10 bits for the empty block, we have already sent |
* (10 - bi_valid) bits. The lookahead for the last real code (before |
* the EOB of the previous block) was thus at least one plus the length |
* of the EOB plus what we have just sent of the empty static block. |
*/ |
if (1 + s->last_eob_len + 10 - s->bi_valid < 9) { |
send_bits(s, STATIC_TREES<<1, 3); |
send_code(s, END_BLOCK, static_ltree); |
#ifdef DEBUG |
s->compressed_len += 10L; |
#endif |
bi_flush(s); |
} |
s->last_eob_len = 7; |
} |
/* =========================================================================== |
* Determine the best encoding for the current block: dynamic trees, static |
990,7 → 972,8 |
} else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) { |
#endif |
send_bits(s, (STATIC_TREES<<1)+last, 3); |
compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree); |
compress_block(s, (const ct_data *)static_ltree, |
(const ct_data *)static_dtree); |
#ifdef DEBUG |
s->compressed_len += 3 + s->static_len; |
#endif |
998,7 → 981,8 |
send_bits(s, (DYN_TREES<<1)+last, 3); |
send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, |
max_blindex+1); |
compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree); |
compress_block(s, (const ct_data *)s->dyn_ltree, |
(const ct_data *)s->dyn_dtree); |
#ifdef DEBUG |
s->compressed_len += 3 + s->opt_len; |
#endif |
1075,8 → 1059,8 |
*/ |
local void compress_block(s, ltree, dtree) |
deflate_state *s; |
ct_data *ltree; /* literal tree */ |
ct_data *dtree; /* distance tree */ |
const ct_data *ltree; /* literal tree */ |
const ct_data *dtree; /* distance tree */ |
{ |
unsigned dist; /* distance of matched string */ |
int lc; /* match length or unmatched char (if dist == 0) */ |
1118,7 → 1102,6 |
} while (lx < s->last_lit); |
send_code(s, END_BLOCK, ltree); |
s->last_eob_len = ltree[END_BLOCK].Len; |
} |
/* =========================================================================== |
1226,7 → 1209,6 |
int header; /* true if block header must be written */ |
{ |
bi_windup(s); /* align on byte boundary */ |
s->last_eob_len = 8; /* enough lookahead for inflate */ |
if (header) { |
put_short(s, (ush)len); |
/programs/develop/libraries/zlib/uncompr.c |
---|
30,7 → 30,7 |
z_stream stream; |
int err; |
stream.next_in = (Bytef*)source; |
stream.next_in = (z_const Bytef *)source; |
stream.avail_in = (uInt)sourceLen; |
/* Check for source > 64K on 16-bit machine: */ |
if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; |
/programs/develop/libraries/zlib/zconf.h |
---|
1,5 → 1,5 |
/* zconf.h -- configuration of the zlib compression library |
* Copyright (C) 1995-2010 Jean-loup Gailly. |
* Copyright (C) 1995-2013 Jean-loup Gailly. |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
15,11 → 15,13 |
* 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 */ |
# 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 |
27,9 → 29,11 |
# define adler32 z_adler32 |
# define adler32_combine z_adler32_combine |
# define adler32_combine64 z_adler32_combine64 |
# 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 |
40,13 → 44,16 |
# 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 |
61,12 → 68,17 |
# define gzerror z_gzerror |
# define gzflush z_gzflush |
# 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 gzvprintf z_gzvprintf |
# define gzputc z_gzputc |
# define gzputs z_gzputs |
# define gzread z_gzread |
78,6 → 90,7 |
# define gztell64 z_gztell64 |
# define gzungetc z_gzungetc |
# define gzwrite z_gzwrite |
# endif |
# define inflate z_inflate |
# define inflateBack z_inflateBack |
# define inflateBackEnd z_inflateBackEnd |
92,16 → 105,22 |
# define inflateReset z_inflateReset |
# define inflateReset2 z_inflateReset2 |
# define inflateSetDictionary z_inflateSetDictionary |
# define inflateGetDictionary z_inflateGetDictionary |
# define inflateSync z_inflateSync |
# define inflateSyncPoint z_inflateSyncPoint |
# define inflateUndermine z_inflateUndermine |
# define inflateResetKeep z_inflateResetKeep |
# 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 |
# 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 |
111,7 → 130,9 |
# 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 |
197,6 → 218,12 |
# endif |
#endif |
#if defined(ZLIB_CONST) && !defined(z_const) |
# define z_const const |
#else |
# define z_const |
#endif |
/* Some Mac compilers merge all .h files incorrectly: */ |
#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) |
# define NO_DUMMY_DECL |
243,6 → 270,14 |
# 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 |
356,14 → 391,49 |
typedef Byte *voidp; |
#endif |
#if 1 /* was set to #if 1 by ./configure */ |
#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 |
370,12 → 440,16 |
* both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as |
* equivalently requesting no 64-bit operations |
*/ |
#if -_LARGEFILE64_SOURCE - -1 == 1 |
#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_* and off_t */ |
# include <unistd.h> /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ |
# ifdef VMS |
# include <unixio.h> /* for off_t */ |
# endif |
383,8 → 457,21 |
# define z_off_t off_t |
# endif |
#endif |
#endif |
#ifndef SEEK_SET |
#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" */ |
394,20 → 481,16 |
# define z_off_t long |
#endif |
#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 |
#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 |
#if defined(__OS400__) |
# define NO_vsnprintf |
#endif |
#if defined(__MVS__) |
# define NO_vsnprintf |
#endif |
/* MVS linker does not support external names larger than 8 bytes */ |
#if defined(__MVS__) |
#pragma map(deflateInit_,"DEIN") |
/programs/develop/libraries/zlib/zlib.h |
---|
1,7 → 1,7 |
/* zlib.h -- interface of the 'zlib' general purpose compression library |
version 1.2.5, April 19th, 2010 |
version 1.2.8, April 28th, 2013 |
Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler |
Copyright (C) 1995-2013 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 |
24,8 → 24,8 |
The data format used by the zlib library is described by RFCs (Request for |
Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt |
(zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). |
Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 |
(zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). |
*/ |
#ifndef ZLIB_H |
37,11 → 37,11 |
extern "C" { |
#endif |
#define ZLIB_VERSION "1.2.5" |
#define ZLIB_VERNUM 0x1250 |
#define ZLIB_VERSION "1.2.8" |
#define ZLIB_VERNUM 0x1280 |
#define ZLIB_VER_MAJOR 1 |
#define ZLIB_VER_MINOR 2 |
#define ZLIB_VER_REVISION 5 |
#define ZLIB_VER_REVISION 8 |
#define ZLIB_VER_SUBREVISION 0 |
/* |
83,15 → 83,15 |
struct internal_state; |
typedef struct z_stream_s { |
Bytef *next_in; /* next input byte */ |
z_const Bytef *next_in; /* next input byte */ |
uInt avail_in; /* number of bytes available at next_in */ |
uLong total_in; /* total nb of input bytes read so far */ |
uLong total_in; /* total number of input bytes read so far */ |
Bytef *next_out; /* next output byte should be put there */ |
uInt avail_out; /* remaining free space at next_out */ |
uLong total_out; /* total nb of bytes output so far */ |
uLong total_out; /* total number of bytes output so far */ |
char *msg; /* last error message, NULL if no error */ |
z_const char *msg; /* last error message, NULL if no error */ |
struct internal_state FAR *state; /* not visible by applications */ |
alloc_func zalloc; /* used to allocate the internal state */ |
327,8 → 327,9 |
Z_FINISH can be used immediately after deflateInit if all the compression |
is to be done in a single step. In this case, avail_out must be at least the |
value returned by deflateBound (see below). If deflate does not return |
Z_STREAM_END, then it must be called again as described above. |
value returned by deflateBound (see below). Then deflate is guaranteed to |
return Z_STREAM_END. If not enough output space is provided, deflate will |
not return Z_STREAM_END, and it must be called again as described above. |
deflate() sets strm->adler to the adler32 checksum of all input read |
so far (that is, total_in bytes). |
451,23 → 452,29 |
error. However if all decompression is to be performed in a single step (a |
single call of inflate), the parameter flush should be set to Z_FINISH. In |
this case all pending input is processed and all pending output is flushed; |
avail_out must be large enough to hold all the uncompressed data. (The size |
of the uncompressed data may have been saved by the compressor for this |
purpose.) The next operation on this stream must be inflateEnd to deallocate |
the decompression state. The use of Z_FINISH is never required, but can be |
used to inform inflate that a faster approach may be used for the single |
inflate() call. |
avail_out must be large enough to hold all of the uncompressed data for the |
operation to complete. (The size of the uncompressed data may have been |
saved by the compressor for this purpose.) The use of Z_FINISH is not |
required to perform an inflation in one step. However it may be used to |
inform inflate that a faster approach can be used for the single inflate() |
call. Z_FINISH also informs inflate to not maintain a sliding window if the |
stream completes, which reduces inflate's memory footprint. If the stream |
does not complete, either because not all of the stream is provided or not |
enough output space is provided, then a sliding window will be allocated and |
inflate() can be called again to continue the operation as if Z_NO_FLUSH had |
been used. |
In this implementation, inflate() always flushes as much output as |
possible to the output buffer, and always uses the faster approach on the |
first call. So the only effect of the flush parameter in this implementation |
is on the return value of inflate(), as noted below, or when it returns early |
because Z_BLOCK or Z_TREES is used. |
first call. So the effects of the flush parameter in this implementation are |
on the return value of inflate() as noted below, when inflate() returns early |
when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of |
memory for a sliding window when Z_FINISH is used. |
If a preset dictionary is needed after this call (see inflateSetDictionary |
below), inflate sets strm->adler to the adler32 checksum of the dictionary |
below), inflate sets strm->adler to the Adler-32 checksum of the dictionary |
chosen by the compressor and returns Z_NEED_DICT; otherwise it sets |
strm->adler to the adler32 checksum of all output produced so far (that is, |
strm->adler to the Adler-32 checksum of all output produced so far (that is, |
total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described |
below. At the end of the stream, inflate() checks that its computed adler32 |
checksum is equal to that saved by the compressor and returns Z_STREAM_END |
478,7 → 485,9 |
initializing with inflateInit2(). Any information contained in the gzip |
header is not retained, so applications that need that information should |
instead use raw inflate, see inflateInit2() below, or inflateBack() and |
perform their own processing of the gzip header and trailer. |
perform their own processing of the gzip header and trailer. When processing |
gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output |
producted so far. The CRC-32 is checked against the gzip trailer. |
inflate() returns Z_OK if some progress has been made (more input processed |
or more output produced), Z_STREAM_END if the end of the compressed data has |
580,10 → 589,15 |
uInt dictLength)); |
/* |
Initializes the compression dictionary from the given byte sequence |
without producing any compressed output. This function must be called |
immediately after deflateInit, deflateInit2 or deflateReset, before any call |
of deflate. The compressor and decompressor must use exactly the same |
dictionary (see inflateSetDictionary). |
without producing any compressed output. When using the zlib format, this |
function must be called immediately after deflateInit, deflateInit2 or |
deflateReset, and before any call of deflate. When doing raw deflate, this |
function must be called either before any call of deflate, or immediately |
after the completion of a deflate block, i.e. after all input has been |
consumed and all output has been delivered when using any of the flush |
options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH. The |
compressor and decompressor must use exactly the same dictionary (see |
inflateSetDictionary). |
The dictionary should consist of strings (byte sequences) that are likely |
to be encountered later in the data to be compressed, with the most commonly |
610,8 → 624,8 |
deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a |
parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is |
inconsistent (for example if deflate has already been called for this stream |
or if the compression method is bsort). deflateSetDictionary does not |
perform any compression: this will be done by deflate(). |
or if not at a block boundary for raw deflate). deflateSetDictionary does |
not perform any compression: this will be done by deflate(). |
*/ |
ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, |
688,9 → 702,29 |
deflation of sourceLen bytes. It must be called after deflateInit() or |
deflateInit2(), and after deflateSetHeader(), if used. This would be used |
to allocate an output buffer for deflation in a single pass, and so would be |
called before deflate(). |
called before deflate(). If that first deflate() call is provided the |
sourceLen input bytes, an output buffer allocated to the size returned by |
deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed |
to return Z_STREAM_END. Note that it is possible for the compressed size to |
be larger than the value returned by deflateBound() if flush options other |
than Z_FINISH or Z_NO_FLUSH are used. |
*/ |
ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, |
unsigned *pending, |
int *bits)); |
/* |
deflatePending() returns the number of bytes and bits of output that have |
been generated, but not yet provided in the available output. The bytes not |
provided would be due to the available output space having being consumed. |
The number of bits of output not provided are between 0 and 7, where they |
await more bits to join them in order to fill out a full byte. If pending |
or bits are Z_NULL, then those values are not set. |
deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source |
stream state was inconsistent. |
*/ |
ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, |
int bits, |
int value)); |
703,8 → 737,9 |
than or equal to 16, and that many of the least significant bits of value |
will be inserted in the output. |
deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source |
stream state was inconsistent. |
deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough |
room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the |
source stream state was inconsistent. |
*/ |
ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, |
790,10 → 825,11 |
if that call returned Z_NEED_DICT. The dictionary chosen by the compressor |
can be determined from the adler32 value returned by that call of inflate. |
The compressor and decompressor must use exactly the same dictionary (see |
deflateSetDictionary). For raw inflate, this function can be called |
immediately after inflateInit2() or inflateReset() and before any call of |
inflate() to set the dictionary. The application must insure that the |
dictionary that was used for compression is provided. |
deflateSetDictionary). For raw inflate, this function can be called at any |
time to set the dictionary. If the provided dictionary is smaller than the |
window and there is already data in the window, then the provided dictionary |
will amend what's there. The application must insure that the dictionary |
that was used for compression is provided. |
inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a |
parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is |
803,19 → 839,38 |
inflate(). |
*/ |
ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm, |
Bytef *dictionary, |
uInt *dictLength)); |
/* |
Returns the sliding dictionary being maintained by inflate. dictLength is |
set to the number of bytes in the dictionary, and that many bytes are copied |
to dictionary. dictionary must have enough space, where 32768 bytes is |
always enough. If inflateGetDictionary() is called with dictionary equal to |
Z_NULL, then only the dictionary length is returned, and nothing is copied. |
Similary, if dictLength is Z_NULL, then it is not set. |
inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the |
stream state is inconsistent. |
*/ |
ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); |
/* |
Skips invalid compressed data until a full flush point (see above the |
description of deflate with Z_FULL_FLUSH) can be found, or until all |
Skips invalid compressed data until a possible full flush point (see above |
for the description of deflate with Z_FULL_FLUSH) can be found, or until all |
available input is skipped. No output is provided. |
inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR |
if no more input was provided, Z_DATA_ERROR if no flush point has been |
found, or Z_STREAM_ERROR if the stream structure was inconsistent. In the |
success case, the application may save the current current value of total_in |
which indicates where valid compressed data was found. In the error case, |
the application may repeatedly call inflateSync, providing more input each |
time, until success or end of the input data. |
inflateSync searches for a 00 00 FF FF pattern in the compressed data. |
All full flush points have this pattern, but not all occurrences of this |
pattern are full flush points. |
inflateSync returns Z_OK if a possible full flush point has been found, |
Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point |
has been found, or Z_STREAM_ERROR if the stream structure was inconsistent. |
In the success case, the application may save the current current value of |
total_in which indicates where valid compressed data was found. In the |
error case, the application may repeatedly call inflateSync, providing more |
input each time, until success or end of the input data. |
*/ |
ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, |
962,12 → 1017,13 |
See inflateBack() for the usage of these routines. |
inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of |
the paramaters are invalid, Z_MEM_ERROR if the internal state could not be |
the parameters are invalid, Z_MEM_ERROR if the internal state could not be |
allocated, or Z_VERSION_ERROR if the version of the library does not match |
the version of the header file. |
*/ |
typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); |
typedef unsigned (*in_func) OF((void FAR *, |
z_const unsigned char FAR * FAR *)); |
typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); |
ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, |
975,11 → 1031,12 |
out_func out, void FAR *out_desc)); |
/* |
inflateBack() does a raw inflate with a single call using a call-back |
interface for input and output. This is more efficient than inflate() for |
file i/o applications in that it avoids copying between the output and the |
sliding window by simply making the window itself the output buffer. This |
function trusts the application to not change the output buffer passed by |
the output function, at least until inflateBack() returns. |
interface for input and output. This is potentially more efficient than |
inflate() for file i/o applications, in that it avoids copying between the |
output and the sliding window by simply making the window itself the output |
buffer. inflate() can be faster on modern CPUs when used with large |
buffers. inflateBack() trusts the application to not change the output |
buffer passed by the output function, at least until inflateBack() returns. |
inflateBackInit() must be called first to allocate the internal state |
and to initialize the state with the user-provided window buffer. |
1088,6 → 1145,7 |
27-31: 0 (reserved) |
*/ |
#ifndef Z_SOLO |
/* utility functions */ |
1149,10 → 1207,11 |
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not |
enough memory, Z_BUF_ERROR if there was not enough room in the output |
buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. |
buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. In |
the case where there is not enough room, uncompress() will fill the output |
buffer with the uncompressed data up to that point. |
*/ |
/* gzip file access functions */ |
/* |
1162,7 → 1221,7 |
wrapper, documented in RFC 1952, wrapped around a deflate stream. |
*/ |
typedef voidp gzFile; /* opaque gzip file descriptor */ |
typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ |
/* |
ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); |
1172,13 → 1231,28 |
a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only |
compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F' |
for fixed code compression as in "wb9F". (See the description of |
deflateInit2 for more information about the strategy parameter.) Also "a" |
can be used instead of "w" to request that the gzip stream that will be |
written be appended to the file. "+" will result in an error, since reading |
and writing to the same gzip file is not supported. |
deflateInit2 for more information about the strategy parameter.) 'T' will |
request transparent writing or appending with no compression and not using |
the gzip format. |
"a" can be used instead of "w" to request that the gzip stream that will |
be written be appended to the file. "+" will result in an error, since |
reading and writing to the same gzip file is not supported. The addition of |
"x" when writing will create the file exclusively, which fails if the file |
already exists. On systems that support it, the addition of "e" when |
reading or writing will set the flag to close the file on an execve() call. |
These functions, as well as gzip, will read and decode a sequence of gzip |
streams in a file. The append function of gzopen() can be used to create |
such a file. (Also see gzflush() for another way to do this.) When |
appending, gzopen does not test whether the file begins with a gzip stream, |
nor does it look for the end of the gzip streams to begin appending. gzopen |
will simply append a gzip stream to the existing file. |
gzopen can be used to read a file which is not in gzip format; in this |
case gzread will directly read from the file without decompression. |
case gzread will directly read from the file without decompression. When |
reading, this will be detected automatically by looking for the magic two- |
byte gzip header. |
gzopen returns NULL if the file could not be opened, if there was |
insufficient memory to allocate the gzFile state, or if an invalid mode was |
1197,7 → 1271,11 |
descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor |
fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd, |
mode);. The duplicated descriptor should be saved to avoid a leak, since |
gzdopen does not close fd if it fails. |
gzdopen does not close fd if it fails. If you are using fileno() to get the |
file descriptor from a FILE *, then you will have to use dup() to avoid |
double-close()ing the file descriptor. Both gzclose() and fclose() will |
close the associated file descriptor, so they need to have different file |
descriptors. |
gzdopen returns NULL if there was insufficient memory to allocate the |
gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not |
1235,15 → 1313,27 |
ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); |
/* |
Reads the given number of uncompressed bytes from the compressed file. If |
the input file was not in gzip format, gzread copies the given number of |
bytes into the buffer. |
the input file is not in gzip format, gzread copies the given number of |
bytes into the buffer directly from the file. |
After reaching the end of a gzip stream in the input, gzread will continue |
to read, looking for another gzip stream, or failing that, reading the rest |
of the input file directly without decompression. The entire input file |
will be read if gzread is called until it returns less than the requested |
len. |
to read, looking for another gzip stream. Any number of gzip streams may be |
concatenated in the input file, and will all be decompressed by gzread(). |
If something other than a gzip stream is encountered after a gzip stream, |
that remaining trailing garbage is ignored (and no error is returned). |
gzread can be used to read a gzip file that is being concurrently written. |
Upon reaching the end of the input, gzread will return with the available |
data. If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then |
gzclearerr can be used to clear the end of file indicator in order to permit |
gzread to be tried again. Z_OK indicates that a gzip stream was completed |
on the last gzread. Z_BUF_ERROR indicates that the input file ended in the |
middle of a gzip stream. Note that gzread does not return -1 in the event |
of an incomplete gzip stream. This error is deferred until gzclose(), which |
will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip |
stream. Alternatively, gzerror can be used before gzclose to detect this |
case. |
gzread returns the number of uncompressed bytes actually read, less than |
len for end of file, or -1 for error. |
*/ |
1256,7 → 1346,7 |
error. |
*/ |
ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); |
ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); |
/* |
Converts, formats, and writes the arguments to the compressed file under |
control of the format string, as in fprintf. gzprintf returns the number of |
1301,7 → 1391,10 |
ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); |
/* |
Reads one byte from the compressed file. gzgetc returns this byte or -1 |
in case of end of file or error. |
in case of end of file or error. This is implemented as a macro for speed. |
As such, it does not do all of the checking the other functions do. I.e. |
it does not check to see if file is NULL, nor whether the structure file |
points to has been clobbered or not. |
*/ |
ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); |
1397,9 → 1490,7 |
ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); |
/* |
Returns true (1) if file is being copied directly while reading, or false |
(0) if file is a gzip stream being decompressed. This state can change from |
false to true while reading the input file if the end of a gzip stream is |
reached, but is followed by data that is not another gzip stream. |
(0) if file is a gzip stream being decompressed. |
If the input file is empty, gzdirect() will return true, since the input |
does not contain a gzip stream. |
1408,6 → 1499,13 |
cause buffers to be allocated to allow reading the file to determine if it |
is a gzip file. Therefore if gzbuffer() is used, it should be called before |
gzdirect(). |
When writing, gzdirect() returns true (1) if transparent writing was |
requested ("wT" for the gzopen() mode), or false (0) otherwise. (Note: |
gzdirect() is not needed when writing. Transparent writing must be |
explicitly requested, so the application already knows the answer. When |
linking statically, using gzdirect() will include all of the zlib code for |
gzip file reading and decompression, which may not be desired.) |
*/ |
ZEXTERN int ZEXPORT gzclose OF((gzFile file)); |
1419,7 → 1517,8 |
must not be called more than once on the same allocation. |
gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a |
file operation error, or Z_OK on success. |
file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the |
last read ended in the middle of a gzip stream, or Z_OK on success. |
*/ |
ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); |
1457,6 → 1556,7 |
file that is being written concurrently. |
*/ |
#endif /* !Z_SOLO */ |
/* checksum functions */ |
1492,7 → 1592,9 |
Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 |
and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for |
each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of |
seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. |
seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note |
that the z_off_t type (like off_t) is a signed integer. If len2 is |
negative, the result has no meaning or utility. |
*/ |
ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); |
1499,9 → 1601,8 |
/* |
Update a running CRC-32 with the bytes buf[0..len-1] and return the |
updated CRC-32. If buf is Z_NULL, this function returns the required |
initial value for the for the crc. Pre- and post-conditioning (one's |
complement) is performed within this function so it shouldn't be done by the |
application. |
initial value for the crc. Pre- and post-conditioning (one's complement) is |
performed within this function so it shouldn't be done by the application. |
Usage example: |
1544,18 → 1645,43 |
const char *version, |
int stream_size)); |
#define deflateInit(strm, level) \ |
deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) |
deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) |
#define inflateInit(strm) \ |
inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) |
inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) |
#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ |
deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ |
(strategy), ZLIB_VERSION, sizeof(z_stream)) |
(strategy), ZLIB_VERSION, (int)sizeof(z_stream)) |
#define inflateInit2(strm, windowBits) \ |
inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) |
inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ |
(int)sizeof(z_stream)) |
#define inflateBackInit(strm, windowBits, window) \ |
inflateBackInit_((strm), (windowBits), (window), \ |
ZLIB_VERSION, sizeof(z_stream)) |
ZLIB_VERSION, (int)sizeof(z_stream)) |
#ifndef Z_SOLO |
/* gzgetc() macro and its supporting function and exposed data structure. Note |
* that the real internal state is much larger than the exposed structure. |
* This abbreviated structure exposes just enough for the gzgetc() macro. The |
* user should not mess with these exposed elements, since their names or |
* behavior could change in the future, perhaps even capriciously. They can |
* only be used by the gzgetc() macro. You have been warned. |
*/ |
struct gzFile_s { |
unsigned have; |
unsigned char *next; |
z_off64_t pos; |
}; |
ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ |
#ifdef Z_PREFIX_SET |
# undef z_gzgetc |
# define z_gzgetc(g) \ |
((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g)) |
#else |
# define gzgetc(g) \ |
((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g)) |
#endif |
/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or |
* change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if |
* both are true, the application gets the *64 functions, and the regular |
1562,7 → 1688,7 |
* functions are changed to 64 bits) -- in case these are set on systems |
* without large file support, _LFS64_LARGEFILE must also be true |
*/ |
#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 |
#ifdef Z_LARGE64 |
ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); |
ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); |
ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); |
1571,7 → 1697,15 |
ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); |
#endif |
#if !defined(ZLIB_INTERNAL) && _FILE_OFFSET_BITS-0 == 64 && _LFS64_LARGEFILE-0 |
#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) |
# ifdef Z_PREFIX_SET |
# define z_gzopen z_gzopen64 |
# define z_gzseek z_gzseek64 |
# define z_gztell z_gztell64 |
# define z_gzoffset z_gzoffset64 |
# define z_adler32_combine z_adler32_combine64 |
# define z_crc32_combine z_crc32_combine64 |
# else |
# define gzopen gzopen64 |
# define gzseek gzseek64 |
# define gztell gztell64 |
1578,7 → 1712,8 |
# define gzoffset gzoffset64 |
# define adler32_combine adler32_combine64 |
# define crc32_combine crc32_combine64 |
# ifdef _LARGEFILE64_SOURCE |
# endif |
# ifndef Z_LARGE64 |
ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); |
ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); |
ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); |
1595,6 → 1730,13 |
ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); |
#endif |
#else /* Z_SOLO */ |
ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); |
ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); |
#endif /* !Z_SOLO */ |
/* hack for buggy compilers */ |
#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) |
struct internal_state {int dummy;}; |
1603,8 → 1745,21 |
/* undocumented functions */ |
ZEXTERN const char * ZEXPORT zError OF((int)); |
ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); |
ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); |
ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void)); |
ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); |
ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); |
ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); |
#if defined(_WIN32) && !defined(Z_SOLO) |
ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path, |
const char *mode)); |
#endif |
#if defined(STDC) || defined(Z_HAVE_STDARG_H) |
# ifndef Z_SOLO |
ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file, |
const char *format, |
va_list va)); |
# endif |
#endif |
#ifdef __cplusplus |
} |
/programs/develop/libraries/zlib/zutil.c |
---|
1,5 → 1,5 |
/* zutil.c -- target dependent utility functions for the compression library |
* Copyright (C) 1995-2005, 2010 Jean-loup Gailly. |
* Copyright (C) 1995-2005, 2010, 2011, 2012 Jean-loup Gailly. |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
6,12 → 6,15 |
/* @(#) $Id$ */ |
#include "zutil.h" |
#ifndef Z_SOLO |
# include "gzguts.h" |
#endif |
#ifndef NO_DUMMY_DECL |
struct internal_state {int dummy;}; /* for buggy compilers */ |
#endif |
const char * const z_errmsg[10] = { |
z_const char * const z_errmsg[10] = { |
"need dictionary", /* Z_NEED_DICT 2 */ |
"stream end", /* Z_STREAM_END 1 */ |
"", /* Z_OK 0 */ |
85,7 → 88,7 |
#ifdef FASTEST |
flags += 1L << 21; |
#endif |
#ifdef STDC |
#if defined(STDC) || defined(Z_HAVE_STDARG_H) |
# ifdef NO_vsnprintf |
flags += 1L << 25; |
# ifdef HAS_vsprintf_void |
181,6 → 184,7 |
} |
#endif |
#ifndef Z_SOLO |
#ifdef SYS16BIT |
316,3 → 320,5 |
} |
#endif /* MY_ZCALLOC */ |
#endif /* !Z_SOLO */ |
/programs/develop/libraries/zlib/zutil.h |
---|
1,5 → 1,5 |
/* zutil.h -- internal interface and configuration of the compression library |
* Copyright (C) 1995-2010 Jean-loup Gailly. |
* Copyright (C) 1995-2013 Jean-loup Gailly. |
* For conditions of distribution and use, see copyright notice in zlib.h |
*/ |
13,7 → 13,7 |
#ifndef ZUTIL_H |
#define ZUTIL_H |
#if ((__GNUC__-0) * 10 + __GNUC_MINOR__-0 >= 33) && !defined(NO_VIZ) |
#ifdef HAVE_HIDDEN |
# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) |
#else |
# define ZLIB_INTERNAL |
21,7 → 21,7 |
#include "zlib.h" |
#ifdef STDC |
#if defined(STDC) && !defined(Z_SOLO) |
# if !(defined(_WIN32_WCE) && defined(_MSC_VER)) |
# include <stddef.h> |
# endif |
29,6 → 29,10 |
# include <stdlib.h> |
#endif |
#ifdef Z_SOLO |
typedef long ptrdiff_t; /* guess -- will be caught if guess is wrong */ |
#endif |
#ifndef local |
# define local static |
#endif |
40,13 → 44,13 |
typedef ush FAR ushf; |
typedef unsigned long ulg; |
extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ |
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 = (char*)ERR_MSG(err), (err)) |
return (strm->msg = ERR_MSG(err), (err)) |
/* To be used only when the state is known to be valid */ |
/* common constants */ |
78,6 → 82,7 |
#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 */ |
90,6 → 95,7 |
# include <malloc.h> |
# endif |
#endif |
#endif |
#ifdef AMIGA |
# define OS_CODE 0x01 |
107,7 → 113,7 |
#ifdef OS2 |
# define OS_CODE 0x06 |
# ifdef M_I86 |
# if defined(M_I86) && !defined(Z_SOLO) |
# include <malloc.h> |
# endif |
#endif |
114,6 → 120,7 |
#if defined(MACOS) || defined(TARGET_OS_MAC) |
# define OS_CODE 0x07 |
# ifndef Z_SOLO |
# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os |
# include <unix.h> /* for fdopen */ |
# else |
122,6 → 129,7 |
# endif |
# endif |
#endif |
#endif |
#ifdef TOPS20 |
# define OS_CODE 0x0a |
153,7 → 161,7 |
# endif |
#endif |
#if defined(__BORLANDC__) |
#if defined(__BORLANDC__) && !defined(MSDOS) |
#pragma warn -8004 |
#pragma warn -8008 |
#pragma warn -8066 |
160,7 → 168,8 |
#endif |
/* provide prototypes for these when building zlib without LFS */ |
#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 |
#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 |
177,42 → 186,7 |
/* functions */ |
#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 |
#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 |
#endif |
#ifdef VMS |
# define NO_vsnprintf |
#endif |
#if defined(pyr) |
#if defined(pyr) || defined(Z_SOLO) |
# define NO_MEMCPY |
#endif |
#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) |
261,10 → 235,11 |
# 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)) |
271,4 → 246,8 |
#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 */ |