zlib 1.2.2.4
This commit is contained in:
Mark Adler
parent
6b8233bfe0
commit
9c3a583021
26
ChangeLog
26
ChangeLog
@ -1,6 +1,30 @@
|
||||
|
||||
ChangeLog file for zlib
|
||||
|
||||
Changes in 1.2.2.4 (11 July 2005)
|
||||
- Add inflatePrime() function for starting inflation at bit boundary
|
||||
- Avoid some Visual C warnings in deflate.c
|
||||
- Avoid more silly Visual C warnings in inflate.c and inftrees.c for 64-bit
|
||||
compile
|
||||
- Fix some spelling errors in comments [Betts]
|
||||
- Correct inflateInit2() error return documentation in zlib.h
|
||||
- Added zran.c example of compressed data random access to examples
|
||||
directory, shows use of inflatePrime()
|
||||
- Fix cast for assignments to strm->state in inflate.c and infback.c
|
||||
- Fix zlibCompileFlags() in zutil.c to use 1L for long shifts [Oberhumer]
|
||||
- Move declarations of gf2 functions to right place in crc32.c [Oberhumer]
|
||||
- Add cast in trees.c t avoid a warning [Oberhumer]
|
||||
- Avoid some warnings in fitblk.c, gun.c, gzjoin.c in examples [Oberhumer]
|
||||
- Update make_vms.com [Zinser]
|
||||
- Initialize state->write in inflateReset() since copied in inflate_fast()
|
||||
- Be more strict on incomplete code sets in inflate_table() and increase
|
||||
ENOUGH and MAXD -- this repairs a possible security vulnerability for
|
||||
invalid inflate input. Thanks to Tavis Ormandy and Markus Oberhumer for
|
||||
discovering the vulnerability and providing test cases.
|
||||
- Add ia64 support to configure for HP-UX [Smith]
|
||||
- Add error return to gzread() for format or i/o error [Levin]
|
||||
- Use malloc.h for OS/2 [Necasek]
|
||||
|
||||
Changes in 1.2.2.3 (27 May 2005)
|
||||
- Replace 1U constants in inflate.c and inftrees.c for 64-bit compile
|
||||
- Typecast fread() return values in gzio.c [Vollant]
|
||||
@ -511,7 +535,7 @@ Changes in 1.0.7 (20 Jan 1998)
|
||||
Changes in 1.0.6 (19 Jan 1998)
|
||||
- add functions gzprintf, gzputc, gzgetc, gztell, gzeof, gzseek, gzrewind and
|
||||
gzsetparams (thanks to Roland Giersig and Kevin Ruland for some of this code)
|
||||
- Fix a deflate bug occuring only with compression level 0 (thanks to
|
||||
- Fix a deflate bug occurring only with compression level 0 (thanks to
|
||||
Andy Buckler for finding this one).
|
||||
- In minigzip, pass transparently also the first byte for .Z files.
|
||||
- return Z_BUF_ERROR instead of Z_OK if output buffer full in uncompress()
|
||||
|
||||
4
Makefile
4
Makefile
@ -1,5 +1,5 @@
|
||||
# Makefile for zlib
|
||||
# Copyright (C) 1995-2003 Jean-loup Gailly.
|
||||
# Copyright (C) 1995-2005 Jean-loup Gailly.
|
||||
# For conditions of distribution and use, see copyright notice in zlib.h
|
||||
|
||||
# To compile and test, type:
|
||||
@ -30,7 +30,7 @@ CPP=$(CC) -E
|
||||
|
||||
LIBS=libz.a
|
||||
SHAREDLIB=libz.so
|
||||
SHAREDLIBV=libz.so.1.2.2.3
|
||||
SHAREDLIBV=libz.so.1.2.2.4
|
||||
SHAREDLIBM=libz.so.1
|
||||
|
||||
AR=ar rc
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
# Makefile for zlib
|
||||
# Copyright (C) 1995-2003 Jean-loup Gailly.
|
||||
# Copyright (C) 1995-2005 Jean-loup Gailly.
|
||||
# For conditions of distribution and use, see copyright notice in zlib.h
|
||||
|
||||
# To compile and test, type:
|
||||
@ -30,7 +30,7 @@ CPP=$(CC) -E
|
||||
|
||||
LIBS=libz.a
|
||||
SHAREDLIB=libz.so
|
||||
SHAREDLIBV=libz.so.1.2.2.3
|
||||
SHAREDLIBV=libz.so.1.2.2.4
|
||||
SHAREDLIBM=libz.so.1
|
||||
|
||||
AR=ar rc
|
||||
|
||||
4
README
4
README
@ -1,6 +1,6 @@
|
||||
ZLIB DATA COMPRESSION LIBRARY
|
||||
|
||||
zlib 1.2.2.3 is a general purpose data compression library. All the code is
|
||||
zlib 1.2.2.4 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)
|
||||
@ -33,7 +33,7 @@ Mark Nelson <markn@ieee.org> wrote an article about zlib for the Jan. 1997
|
||||
issue of Dr. Dobb's Journal; a copy of the article is available in
|
||||
http://dogma.net/markn/articles/zlibtool/zlibtool.htm
|
||||
|
||||
The changes made in version 1.2.2.3 are documented in the file ChangeLog.
|
||||
The changes made in version 1.2.2.4 are documented in the file ChangeLog.
|
||||
|
||||
Unsupported third party contributions are provided in directory "contrib".
|
||||
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
* ZLIB.INC - Interface to the general purpose compression library
|
||||
*
|
||||
* ILE RPG400 version by Patrick Monnerat, DATASPHERE.
|
||||
* Version 1.2.2.3
|
||||
* Version 1.2.2.4
|
||||
*
|
||||
*
|
||||
* WARNING:
|
||||
@ -22,8 +22,8 @@
|
||||
*
|
||||
* Versioning information.
|
||||
*
|
||||
D ZLIB_VERSION C '1.2.2.3'
|
||||
D ZLIB_VERNUM C X'1223'
|
||||
D ZLIB_VERSION C '1.2.2.4'
|
||||
D ZLIB_VERNUM C X'1224'
|
||||
*
|
||||
* Other equates.
|
||||
*
|
||||
|
||||
15
configure
vendored
15
configure
vendored
@ -82,9 +82,16 @@ if test "$gcc" -eq 1 && ($cc -c $cflags $test.c) 2>/dev/null; then
|
||||
QNX*) # This is for QNX6. I suppose that the QNX rule below is for QNX2,QNX4
|
||||
# (alain.bonnefoy@icbt.com)
|
||||
LDSHARED=${LDSHARED-"$cc -shared -Wl,-hlibz.so.1"};;
|
||||
HP-UX*) LDSHARED=${LDSHARED-"$cc -shared $SFLAGS"}
|
||||
HP-UX*)
|
||||
LDSHARED=${LDSHARED-"$cc -shared $SFLAGS"}
|
||||
case `(uname -m || echo unknown) 2>/dev/null` in
|
||||
ia64)
|
||||
shared_ext='.so'
|
||||
SHAREDLIB='libz.so';;
|
||||
*)
|
||||
shared_ext='.sl'
|
||||
SHAREDLIB='libz.sl';;
|
||||
esac;;
|
||||
Darwin*) shared_ext='.dylib'
|
||||
SHAREDLIB=libz$shared_ext
|
||||
SHAREDLIBV=libz.$VER$shared_ext
|
||||
@ -100,8 +107,14 @@ else
|
||||
CFLAGS=${CFLAGS-"-O"}
|
||||
# LDSHARED=${LDSHARED-"ld -b +vnocompatwarnings"}
|
||||
LDSHARED=${LDSHARED-"ld -b"}
|
||||
case `(uname -m || echo unknown) 2>/dev/null` in
|
||||
ia64)
|
||||
shared_ext='.so'
|
||||
SHAREDLIB='libz.so';;
|
||||
*)
|
||||
shared_ext='.sl'
|
||||
SHAREDLIB='libz.sl';;
|
||||
esac;;
|
||||
IRIX*) SFLAGS=${CFLAGS-"-ansi -O2 -rpath ."}
|
||||
CFLAGS=${CFLAGS-"-ansi -O2"}
|
||||
LDSHARED=${LDSHARED-"cc -shared"};;
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
#define MAXBITS 15
|
||||
|
||||
const char inflate9_copyright[] =
|
||||
" inflate9 1.2.2.3 Copyright 1995-2005 Mark Adler ";
|
||||
" inflate9 1.2.2.4 Copyright 1995-2005 Mark Adler ";
|
||||
/*
|
||||
If you use the zlib library in a product, an acknowledgment is welcome
|
||||
in the documentation of your product. If for some reason you cannot
|
||||
@ -64,7 +64,7 @@ unsigned short FAR *work;
|
||||
static const unsigned short lext[31] = { /* Length codes 257..285 extra */
|
||||
128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129,
|
||||
130, 130, 130, 130, 131, 131, 131, 131, 132, 132, 132, 132,
|
||||
133, 133, 133, 133, 144, 66, 71};
|
||||
133, 133, 133, 133, 144, 206, 69};
|
||||
static const unsigned short dbase[32] = { /* Distance codes 0..31 base */
|
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49,
|
||||
65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073,
|
||||
|
||||
@ -2,8 +2,8 @@
|
||||
|
||||
#define IDR_VERSION1 1
|
||||
IDR_VERSION1 VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE
|
||||
FILEVERSION 1,2,2,3
|
||||
PRODUCTVERSION 1,2,2,3
|
||||
FILEVERSION 1,2,2,4
|
||||
PRODUCTVERSION 1,2,2,4
|
||||
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
|
||||
FILEFLAGS 0
|
||||
FILEOS VOS_DOS_WINDOWS32
|
||||
@ -17,7 +17,7 @@ BEGIN
|
||||
|
||||
BEGIN
|
||||
VALUE "FileDescription", "zlib data compression library\0"
|
||||
VALUE "FileVersion", "1.2.2.3\0"
|
||||
VALUE "FileVersion", "1.2.2.4\0"
|
||||
VALUE "InternalName", "zlib\0"
|
||||
VALUE "OriginalFilename", "zlib.dll\0"
|
||||
VALUE "ProductName", "ZLib.DLL\0"
|
||||
|
||||
9
crc32.c
9
crc32.c
@ -64,6 +64,11 @@
|
||||
# define TBLS 1
|
||||
#endif /* BYFOUR */
|
||||
|
||||
/* Local functions for crc concatenation */
|
||||
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));
|
||||
|
||||
#ifdef DYNAMIC_CRC_TABLE
|
||||
|
||||
local volatile int crc_table_empty = 1;
|
||||
@ -72,10 +77,6 @@ local void make_crc_table OF((void));
|
||||
#ifdef MAKECRCH
|
||||
local void write_table OF((FILE *, const unsigned long FAR *));
|
||||
#endif /* MAKECRCH */
|
||||
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));
|
||||
|
||||
/*
|
||||
Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
|
||||
x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
|
||||
|
||||
82
deflate.c
82
deflate.c
@ -52,7 +52,7 @@
|
||||
#include "deflate.h"
|
||||
|
||||
const char deflate_copyright[] =
|
||||
" deflate 1.2.2.3 Copyright 1995-2005 Jean-loup Gailly ";
|
||||
" deflate 1.2.2.4 Copyright 1995-2005 Jean-loup Gailly ";
|
||||
/*
|
||||
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
|
||||
@ -600,10 +600,10 @@ int ZEXPORT deflate (strm, flush)
|
||||
(s->gzhead->name == Z_NULL ? 0 : 8) +
|
||||
(s->gzhead->comment == Z_NULL ? 0 : 16)
|
||||
);
|
||||
put_byte(s, s->gzhead->time & 0xff);
|
||||
put_byte(s, (s->gzhead->time >> 8) & 0xff);
|
||||
put_byte(s, (s->gzhead->time >> 16) & 0xff);
|
||||
put_byte(s, (s->gzhead->time >> 24) & 0xff);
|
||||
put_byte(s, (Byte)(s->gzhead->time & 0xff));
|
||||
put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
|
||||
put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
|
||||
put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
|
||||
put_byte(s, s->level == 9 ? 2 :
|
||||
(s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
|
||||
4 : 0));
|
||||
@ -651,7 +651,7 @@ int ZEXPORT deflate (strm, flush)
|
||||
#ifdef GZIP
|
||||
if (s->status == EXTRA_STATE) {
|
||||
if (s->gzhead->extra != NULL) {
|
||||
int beg = s->pending; /* start of bytes to update crc */
|
||||
uInt beg = s->pending; /* start of bytes to update crc */
|
||||
|
||||
while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {
|
||||
if (s->pending == s->pending_buf_size) {
|
||||
@ -679,7 +679,7 @@ int ZEXPORT deflate (strm, flush)
|
||||
}
|
||||
if (s->status == NAME_STATE) {
|
||||
if (s->gzhead->name != NULL) {
|
||||
int beg = s->pending; /* start of bytes to update crc */
|
||||
uInt beg = s->pending; /* start of bytes to update crc */
|
||||
int val;
|
||||
|
||||
do {
|
||||
@ -710,7 +710,7 @@ int ZEXPORT deflate (strm, flush)
|
||||
}
|
||||
if (s->status == COMMENT_STATE) {
|
||||
if (s->gzhead->comment != NULL) {
|
||||
int beg = s->pending; /* start of bytes to update crc */
|
||||
uInt beg = s->pending; /* start of bytes to update crc */
|
||||
int val;
|
||||
|
||||
do {
|
||||
@ -742,8 +742,8 @@ int ZEXPORT deflate (strm, flush)
|
||||
if (s->pending + 2 > s->pending_buf_size)
|
||||
flush_pending(strm);
|
||||
if (s->pending + 2 <= s->pending_buf_size) {
|
||||
put_byte(s, strm->adler & 0xff);
|
||||
put_byte(s, (strm->adler >> 8) & 0xff);
|
||||
put_byte(s, (Byte)(strm->adler & 0xff));
|
||||
put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
|
||||
strm->adler = crc32(0L, Z_NULL, 0);
|
||||
s->status = BUSY_STATE;
|
||||
}
|
||||
@ -1303,6 +1303,7 @@ local void fill_window(s)
|
||||
later. (Using level 0 permanently is not an optimal usage of
|
||||
zlib, so we don't care about this pathological case.)
|
||||
*/
|
||||
/* %%% avoid this when Z_RLE */
|
||||
n = s->hash_size;
|
||||
p = &s->head[n];
|
||||
do {
|
||||
@ -1672,3 +1673,64 @@ local block_state deflate_slow(s, flush)
|
||||
return flush == Z_FINISH ? finish_done : block_done;
|
||||
}
|
||||
#endif /* FASTEST */
|
||||
|
||||
#if 0
|
||||
/* ===========================================================================
|
||||
* For Z_RLE, simply look for runs of bytes, generate matches only of distance
|
||||
* one. Do not maintain a hash table. (It will be regenerated if this run of
|
||||
* deflate switches away from Z_RLE.)
|
||||
*/
|
||||
local block_state deflate_rle(s, flush)
|
||||
deflate_state *s;
|
||||
int flush;
|
||||
{
|
||||
int bflush; /* set if current block must be flushed */
|
||||
uInt run; /* length of run */
|
||||
uInt max; /* maximum length of run */
|
||||
uInt prev; /* byte at distance one to match */
|
||||
Bytef *scan; /* scan for end of run */
|
||||
|
||||
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.
|
||||
*/
|
||||
if (s->lookahead < MAX_MATCH) {
|
||||
fill_window(s);
|
||||
if (s->lookahead < MAX_MATCH && flush == Z_NO_FLUSH) {
|
||||
return need_more;
|
||||
}
|
||||
if (s->lookahead == 0) break; /* flush the current block */
|
||||
}
|
||||
|
||||
/* See how many times the previous byte repeats */
|
||||
run = 0;
|
||||
if (s->strstart > 0) { /* if there is a previous byte, that is */
|
||||
max = s->lookahead < MAX_MATCH ? s->lookahead : MAX_MATCH;
|
||||
scan = s->window + s->strstart - 1;
|
||||
prev = *scan++;
|
||||
do {
|
||||
if (*scan++ != prev)
|
||||
break;
|
||||
} while (++run < max);
|
||||
}
|
||||
|
||||
/* Emit match if have run of MIN_MATCH or longer, else emit literal */
|
||||
if (run >= MIN_MATCH) {
|
||||
check_match(s, s->strstart, s->strstart - 1, run);
|
||||
_tr_tally_dist(s, 1, run - MIN_MATCH, bflush);
|
||||
s->lookahead -= run;
|
||||
s->strstart += run;
|
||||
} else {
|
||||
/* No match, output a literal byte */
|
||||
Tracevv((stderr,"%c", s->window[s->strstart]));
|
||||
_tr_tally_lit (s, s->window[s->strstart], bflush);
|
||||
s->lookahead--;
|
||||
s->strstart++;
|
||||
}
|
||||
if (bflush) FLUSH_BLOCK(s, 0);
|
||||
}
|
||||
FLUSH_BLOCK(s, flush == Z_FINISH);
|
||||
return flush == Z_FINISH ? finish_done : block_done;
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -97,10 +97,10 @@ typedef struct internal_state {
|
||||
Bytef *pending_buf; /* output still pending */
|
||||
ulg pending_buf_size; /* size of pending_buf */
|
||||
Bytef *pending_out; /* next pending byte to output to the stream */
|
||||
int pending; /* nb of bytes in the pending buffer */
|
||||
uInt pending; /* nb of bytes in the pending buffer */
|
||||
int wrap; /* bit 0 true for zlib, bit 1 true for gzip */
|
||||
gz_headerp gzhead; /* gzip header information to write */
|
||||
int gzindex; /* where in extra, name, or comment */
|
||||
uInt gzindex; /* where in extra, name, or comment */
|
||||
Byte method; /* STORED (for zip only) or DEFLATED */
|
||||
int last_flush; /* value of flush param for previous deflate call */
|
||||
|
||||
|
||||
@ -35,3 +35,8 @@ zpipe.c
|
||||
reads and writes zlib streams from stdin to stdout
|
||||
- illustrates the proper use of deflate() and inflate()
|
||||
- deeply commented in zlib_how.html (see above)
|
||||
|
||||
zran.c
|
||||
index a zlib or gzip stream and randomly access it
|
||||
- illustrates the use of Z_BLOCK, inflatePrime(), and
|
||||
inflateSetDictionary() to provide random access
|
||||
|
||||
@ -73,7 +73,7 @@ local void quit(char *why)
|
||||
local int partcompress(FILE *in, z_streamp def)
|
||||
{
|
||||
int ret, flush;
|
||||
char raw[RAWLEN];
|
||||
unsigned char raw[RAWLEN];
|
||||
|
||||
flush = Z_NO_FLUSH;
|
||||
do {
|
||||
@ -96,7 +96,7 @@ local int partcompress(FILE *in, z_streamp def)
|
||||
local int recompress(z_streamp inf, z_streamp def)
|
||||
{
|
||||
int ret, flush;
|
||||
char raw[RAWLEN];
|
||||
unsigned char raw[RAWLEN];
|
||||
|
||||
flush = Z_NO_FLUSH;
|
||||
do {
|
||||
@ -129,8 +129,8 @@ int main(int argc, char **argv)
|
||||
int ret; /* return code */
|
||||
unsigned size; /* requested fixed output block size */
|
||||
unsigned have; /* bytes written by deflate() call */
|
||||
char *blk; /* intermediate and final stream */
|
||||
char *tmp; /* close to desired size stream */
|
||||
unsigned char *blk; /* intermediate and final stream */
|
||||
unsigned char *tmp; /* close to desired size stream */
|
||||
z_stream def, inf; /* zlib deflate and inflate states */
|
||||
|
||||
/* get requested output size */
|
||||
@ -163,8 +163,7 @@ int main(int argc, char **argv)
|
||||
if (ret == Z_STREAM_END && def.avail_out >= EXCESS) {
|
||||
/* write block to stdout */
|
||||
have = size + EXCESS - def.avail_out;
|
||||
ret = fwrite(blk, 1, have, stdout);
|
||||
if (ret != have || ferror(stdout))
|
||||
if (fwrite(blk, 1, have, stdout) != have || ferror(stdout))
|
||||
quit("error writing output");
|
||||
|
||||
/* clean up and print results to stderr */
|
||||
@ -217,8 +216,7 @@ int main(int argc, char **argv)
|
||||
|
||||
/* done -- write block to stdout */
|
||||
have = size - def.avail_out;
|
||||
ret = fwrite(blk, 1, have, stdout);
|
||||
if (ret != have || ferror(stdout))
|
||||
if (fwrite(blk, 1, have, stdout) != have || ferror(stdout))
|
||||
quit("error writing output");
|
||||
|
||||
/* clean up and print results to stderr */
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
/* gun.c -- simple gunzip to give an example of the use of inflateBack()
|
||||
* Copyright (C) 2003, 2005 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
Version 1.2 20 March 2005 Mark Adler */
|
||||
Version 1.3 12 June 2005 Mark Adler */
|
||||
|
||||
/* Version history:
|
||||
1.0 16 Feb 2003 First version for testing of inflateBack()
|
||||
@ -14,6 +14,7 @@
|
||||
Add a bunch of comments
|
||||
1.2 20 Mar 2005 Add Unix compress (LZW) decompression
|
||||
Copy file attributes from input file to output file
|
||||
1.3 12 Jun 2005 Add casts for error messages [Oberhumer]
|
||||
*/
|
||||
|
||||
/*
|
||||
@ -221,12 +222,12 @@ local int lunpipe(unsigned have, unsigned char *next, struct ind *indp,
|
||||
if (last == -1)
|
||||
return Z_BUF_ERROR;
|
||||
if (flags & 0x60) {
|
||||
strm->msg = "unknown lzw flags set";
|
||||
strm->msg = (char *)"unknown lzw flags set";
|
||||
return Z_DATA_ERROR;
|
||||
}
|
||||
max = flags & 0x1f;
|
||||
if (max < 9 || max > 16) {
|
||||
strm->msg = "lzw bits out of range";
|
||||
strm->msg = (char *)"lzw bits out of range";
|
||||
return Z_DATA_ERROR;
|
||||
}
|
||||
if (max == 9) /* 9 doesn't really mean 9 */
|
||||
@ -246,7 +247,7 @@ local int lunpipe(unsigned have, unsigned char *next, struct ind *indp,
|
||||
if (NEXT() == -1) /* missing a bit */
|
||||
return Z_BUF_ERROR;
|
||||
if (last & 1) { /* code must be < 256 */
|
||||
strm->msg = "invalid lzw code";
|
||||
strm->msg = (char *)"invalid lzw code";
|
||||
return Z_DATA_ERROR;
|
||||
}
|
||||
rem = (unsigned)last >> 1; /* remaining 7 bits */
|
||||
@ -313,7 +314,7 @@ local int lunpipe(unsigned have, unsigned char *next, struct ind *indp,
|
||||
to detect random or corrupted input after a compress header.
|
||||
In any case, the prev > end check must be retained. */
|
||||
if (code != end + 1 || prev > end) {
|
||||
strm->msg = "invalid lzw code";
|
||||
strm->msg = (char *)"invalid lzw code";
|
||||
return Z_DATA_ERROR;
|
||||
}
|
||||
match[stack++] = (unsigned char)final;
|
||||
@ -394,7 +395,7 @@ local int gunpipe(z_stream *strm, int infile, int outfile)
|
||||
break; /* empty gzip stream is ok */
|
||||
}
|
||||
if (last != 31 || (NEXT() != 139 && last != 157)) {
|
||||
strm->msg = "incorrect header check";
|
||||
strm->msg = (char *)"incorrect header check";
|
||||
ret = first ? Z_DATA_ERROR : Z_ERRNO;
|
||||
break; /* not a gzip or compress header */
|
||||
}
|
||||
@ -410,7 +411,7 @@ local int gunpipe(z_stream *strm, int infile, int outfile)
|
||||
ret = Z_BUF_ERROR;
|
||||
if (NEXT() != 8) { /* only deflate method allowed */
|
||||
if (last == -1) break;
|
||||
strm->msg = "unknown compression method";
|
||||
strm->msg = (char *)"unknown compression method";
|
||||
ret = Z_DATA_ERROR;
|
||||
break;
|
||||
}
|
||||
@ -423,7 +424,7 @@ local int gunpipe(z_stream *strm, int infile, int outfile)
|
||||
NEXT();
|
||||
if (last == -1) break;
|
||||
if (flags & 0xe0) {
|
||||
strm->msg = "unknown header flags set";
|
||||
strm->msg = (char *)"unknown header flags set";
|
||||
ret = Z_DATA_ERROR;
|
||||
break;
|
||||
}
|
||||
@ -476,7 +477,7 @@ local int gunpipe(z_stream *strm, int infile, int outfile)
|
||||
NEXT() != ((outd.crc >> 24) & 0xff)) {
|
||||
/* crc error */
|
||||
if (last != -1) {
|
||||
strm->msg = "incorrect data check";
|
||||
strm->msg = (char *)"incorrect data check";
|
||||
ret = Z_DATA_ERROR;
|
||||
}
|
||||
break;
|
||||
@ -487,7 +488,7 @@ local int gunpipe(z_stream *strm, int infile, int outfile)
|
||||
NEXT() != ((outd.total >> 24) & 0xff)) {
|
||||
/* length error */
|
||||
if (last != -1) {
|
||||
strm->msg = "incorrect length check";
|
||||
strm->msg = (char *)"incorrect length check";
|
||||
ret = Z_DATA_ERROR;
|
||||
}
|
||||
break;
|
||||
@ -641,7 +642,7 @@ int main(int argc, char **argv)
|
||||
argv++;
|
||||
test = 0;
|
||||
if (argc && strcmp(*argv, "-h") == 0) {
|
||||
fprintf(stderr, "gun 1.2 (20 Mar 2005)\n");
|
||||
fprintf(stderr, "gun 1.3 (12 Jun 2005)\n");
|
||||
fprintf(stderr, "Copyright (c) 2005 Mark Adler\n");
|
||||
fprintf(stderr, "usage: gun [-t] [file1.gz [file2.Z ...]]\n");
|
||||
return 0;
|
||||
|
||||
@ -26,6 +26,7 @@
|
||||
* Change history:
|
||||
*
|
||||
* 1.0 11 Dec 2004 - First version
|
||||
* 1.1 12 Jun 2005 - Changed ssize_t to long for portability
|
||||
*/
|
||||
|
||||
/*
|
||||
@ -118,7 +119,7 @@ local bin *bopen(char *name)
|
||||
1 indicating that end-of-file was reached */
|
||||
local int bload(bin *in)
|
||||
{
|
||||
ssize_t len;
|
||||
long len;
|
||||
|
||||
if (in == NULL)
|
||||
return -1;
|
||||
@ -126,7 +127,7 @@ local int bload(bin *in)
|
||||
return 0;
|
||||
in->next = in->buf;
|
||||
do {
|
||||
len = read(in->fd, in->buf + in->left, CHUNK - in->left);
|
||||
len = (long)read(in->fd, in->buf + in->left, CHUNK - in->left);
|
||||
if (len < 0)
|
||||
return -1;
|
||||
in->left += (unsigned)len;
|
||||
|
||||
404
examples/zran.c
Normal file
404
examples/zran.c
Normal file
@ -0,0 +1,404 @@
|
||||
/* zran.c -- example of zlib/gzip stream indexing and random access
|
||||
* Copyright (C) 2005 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
Version 1.0 29 May 2005 Mark Adler */
|
||||
|
||||
/* Illustrate the use of Z_BLOCK, inflatePrime(), and inflateSetDictionary()
|
||||
for random access of a compressed file. A file containing a zlib or gzip
|
||||
stream is provided on the command line. The compressed stream is decoded in
|
||||
its entirety, and an index built with access points about every SPAN bytes
|
||||
in the uncompressed output. The compressed file is left open, and can then
|
||||
be read randomly, having to decompress on the average SPAN/2 uncompressed
|
||||
bytes before getting to the desired block of data.
|
||||
|
||||
An access point can be created at the start of any deflate block, by saving
|
||||
the starting file offset and bit of that block, and the 32K bytes of
|
||||
uncompressed data that precede that block. Also the uncompressed offset of
|
||||
that block is saved to provide a referece for locating a desired starting
|
||||
point in the uncompressed stream. build_index() works by decompressing the
|
||||
input zlib or gzip stream a block at a time, and at the end of each block
|
||||
deciding if enough uncompressed data has gone by to justify the creation of
|
||||
a new access point. If so, that point is saved in a data structure that
|
||||
grows as needed to accommodate the points.
|
||||
|
||||
To use the index, an offset in the uncompressed data is provided, for which
|
||||
the latest accees point at or preceding that offset is located in the index.
|
||||
The input file is positioned to the specified location in the index, and if
|
||||
necessary the first few bits of the compressed data is read from the file.
|
||||
inflate is initialized with those bits and the 32K of uncompressed data, and
|
||||
the decompression then proceeds until the desired offset in the file is
|
||||
reached. Then the decompression continues to read the desired uncompressed
|
||||
data from the file.
|
||||
|
||||
Another approach would be to generate the index on demand. In that case,
|
||||
requests for random access reads from the compressed data would try to use
|
||||
the index, but if a read far enough past the end of the index is required,
|
||||
then further index entries would be generated and added.
|
||||
|
||||
There is some fair bit of overhead to starting inflation for the random
|
||||
access, mainly copying the 32K byte dictionary. So if small pieces of the
|
||||
file are being accessed, it would make sense to implement a cache to hold
|
||||
some lookahead and avoid many calls to extract() for small lengths.
|
||||
|
||||
Another way to build an index would be to use inflateCopy(). That would
|
||||
not be constrained to have access points at block boundaries, but requires
|
||||
more memory per access point, and also cannot be saved to file due to the
|
||||
use of pointers in the state. The approach here allows for storage of the
|
||||
index in a file.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "zlib.h"
|
||||
|
||||
#define local static
|
||||
|
||||
#define SPAN 1048576L /* desired distance between access points */
|
||||
#define WINSIZE 32768U /* sliding window size */
|
||||
#define CHUNK 16384 /* file input buffer size */
|
||||
|
||||
/* access point entry */
|
||||
struct point {
|
||||
off_t out; /* corresponding offset in uncompressed data */
|
||||
off_t in; /* offset in input file of first full byte */
|
||||
int bits; /* number of bits (1-7) from byte at in - 1, or 0 */
|
||||
unsigned char window[WINSIZE]; /* preceding 32K of uncompressed data */
|
||||
};
|
||||
|
||||
/* access point list */
|
||||
struct access {
|
||||
int have; /* number of list entries filled in */
|
||||
int size; /* number of list entries allocated */
|
||||
struct point *list; /* allocated list */
|
||||
};
|
||||
|
||||
/* Deallocate an index built by build_index() */
|
||||
local void free_index(struct access *index)
|
||||
{
|
||||
if (index != NULL) {
|
||||
free(index->list);
|
||||
free(index);
|
||||
}
|
||||
}
|
||||
|
||||
/* Add an entry to the access point list. If out of memory, deallocate the
|
||||
existing list and return NULL. */
|
||||
local struct access *addpoint(struct access *index, int bits,
|
||||
off_t in, off_t out, unsigned left, unsigned char *window)
|
||||
{
|
||||
struct point *next;
|
||||
|
||||
/* if list is empty, create it (start with eight points) */
|
||||
if (index == NULL) {
|
||||
index = malloc(sizeof(struct access));
|
||||
if (index == NULL) return NULL;
|
||||
index->list = malloc(sizeof(struct point) << 3);
|
||||
if (index->list == NULL) {
|
||||
free(index);
|
||||
return NULL;
|
||||
}
|
||||
index->size = 8;
|
||||
index->have = 0;
|
||||
}
|
||||
|
||||
/* if list is full, make it bigger */
|
||||
else if (index->have == index->size) {
|
||||
index->size <<= 1;
|
||||
next = realloc(index->list, sizeof(struct point) * index->size);
|
||||
if (next == NULL) {
|
||||
free_index(index);
|
||||
return NULL;
|
||||
}
|
||||
index->list = next;
|
||||
}
|
||||
|
||||
/* fill in entry and increment how many we have */
|
||||
next = index->list + index->have;
|
||||
next->bits = bits;
|
||||
next->in = in;
|
||||
next->out = out;
|
||||
if (left)
|
||||
memcpy(next->window, window + WINSIZE - left, left);
|
||||
if (left < WINSIZE)
|
||||
memcpy(next->window + left, window, WINSIZE - left);
|
||||
index->have++;
|
||||
|
||||
/* return list, possibly reallocated */
|
||||
return index;
|
||||
}
|
||||
|
||||
/* Make one entire pass through the compressed stream and build an index, with
|
||||
access points about every span bytes of uncompressed output -- span is
|
||||
chosen to balance the speed of random access against the memory requirements
|
||||
of the list, about 32K bytes per access point. Note that data after the end
|
||||
of the first zlib or gzip stream in the file is ignored. build_index()
|
||||
returns the number of access points on success (>= 1), Z_MEM_ERROR for out
|
||||
of memory, Z_DATA_ERROR for an error in the input file, or Z_ERRNO for a
|
||||
file read error. On success, *built points to the resulting index. */
|
||||
local int build_index(FILE *in, off_t span, struct access **built)
|
||||
{
|
||||
int ret;
|
||||
off_t totin, totout; /* our own total counters to avoid 4GB limit */
|
||||
off_t last; /* totout value of last access point */
|
||||
struct access *index; /* access points being generated */
|
||||
z_stream strm;
|
||||
unsigned char input[CHUNK];
|
||||
unsigned char window[WINSIZE];
|
||||
|
||||
/* initialize inflate */
|
||||
strm.zalloc = Z_NULL;
|
||||
strm.zfree = Z_NULL;
|
||||
strm.opaque = Z_NULL;
|
||||
strm.avail_in = 0;
|
||||
strm.next_in = Z_NULL;
|
||||
ret = inflateInit2(&strm, 47); /* automatic zlib or gzip decoding */
|
||||
if (ret != Z_OK)
|
||||
return ret;
|
||||
|
||||
/* inflate the input, maintain a sliding window, and build an index -- this
|
||||
also validates the integrity of the compressed data using the check
|
||||
information at the end of the gzip or zlib stream */
|
||||
totin = totout = last = 0;
|
||||
index = NULL; /* will be allocated by first addpoint() */
|
||||
strm.avail_out = 0;
|
||||
do {
|
||||
/* get some compressed data from input file */
|
||||
strm.avail_in = fread(input, 1, CHUNK, in);
|
||||
if (ferror(in)) {
|
||||
ret = Z_ERRNO;
|
||||
goto build_index_error;
|
||||
}
|
||||
if (strm.avail_in == 0) {
|
||||
ret = Z_DATA_ERROR;
|
||||
goto build_index_error;
|
||||
}
|
||||
strm.next_in = input;
|
||||
|
||||
/* process all of that, or until end of stream */
|
||||
do {
|
||||
/* reset sliding window if necessary */
|
||||
if (strm.avail_out == 0) {
|
||||
strm.avail_out = WINSIZE;
|
||||
strm.next_out = window;
|
||||
}
|
||||
|
||||
/* inflate until out of input, output, or at end of block --
|
||||
update the total input and output counters */
|
||||
totin += strm.avail_in;
|
||||
totout += strm.avail_out;
|
||||
ret = inflate(&strm, Z_BLOCK); /* return at end of block */
|
||||
totin -= strm.avail_in;
|
||||
totout -= strm.avail_out;
|
||||
if (ret == Z_NEED_DICT)
|
||||
ret = Z_DATA_ERROR;
|
||||
if (ret == Z_MEM_ERROR || ret == Z_DATA_ERROR)
|
||||
goto build_index_error;
|
||||
if (ret == Z_STREAM_END)
|
||||
break;
|
||||
|
||||
/* if at end of block, consider adding an index entry (note that if
|
||||
data_type indicates an end-of-block, then all of the
|
||||
uncompressed data from that block has been delivered, and none
|
||||
of the compressed data after that block has been consumed,
|
||||
except for up to seven bits) -- the totout == 0 provides an
|
||||
entry point after the zlib or gzip header, and assures that the
|
||||
index always has at least one access point; we avoid creating an
|
||||
access point after the last block by checking bit 6 of data_type
|
||||
*/
|
||||
if ((strm.data_type & 128) && !(strm.data_type & 64) &&
|
||||
(totout == 0 || totout - last > span)) {
|
||||
index = addpoint(index, strm.data_type & 7, totin,
|
||||
totout, strm.avail_out, window);
|
||||
if (index == NULL) {
|
||||
ret = Z_MEM_ERROR;
|
||||
goto build_index_error;
|
||||
}
|
||||
last = totout;
|
||||
}
|
||||
} while (strm.avail_in != 0);
|
||||
} while (ret != Z_STREAM_END);
|
||||
|
||||
/* clean up and return index (release unused entries in list) */
|
||||
(void)inflateEnd(&strm);
|
||||
index = realloc(index, sizeof(struct point) * index->have);
|
||||
index->size = index->have;
|
||||
*built = index;
|
||||
return index->size;
|
||||
|
||||
/* return error */
|
||||
build_index_error:
|
||||
(void)inflateEnd(&strm);
|
||||
if (index != NULL)
|
||||
free_index(index);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Use the index to read len bytes from offset into buf, return bytes read or
|
||||
negative for error (Z_DATA_ERROR or Z_MEM_ERROR). If data is requested past
|
||||
the end of the uncompressed data, then extract() will return a value less
|
||||
than len, indicating how much as actually read into buf. This function
|
||||
should not return a data error unless the file was modified since the index
|
||||
was generated. extract() may also return Z_ERRNO if there is an error on
|
||||
reading or seeking the input file. */
|
||||
local int extract(FILE *in, struct access *index, off_t offset,
|
||||
unsigned char *buf, int len)
|
||||
{
|
||||
int ret, skip;
|
||||
z_stream strm;
|
||||
struct point *here;
|
||||
unsigned char input[CHUNK];
|
||||
unsigned char discard[WINSIZE];
|
||||
|
||||
/* proceed only if something reasonable to do */
|
||||
if (len < 0)
|
||||
return 0;
|
||||
|
||||
/* find where in stream to start */
|
||||
here = index->list;
|
||||
ret = index->have;
|
||||
while (--ret && here[1].out <= offset)
|
||||
here++;
|
||||
|
||||
/* initialize file and inflate state to start there */
|
||||
strm.zalloc = Z_NULL;
|
||||
strm.zfree = Z_NULL;
|
||||
strm.opaque = Z_NULL;
|
||||
strm.avail_in = 0;
|
||||
strm.next_in = Z_NULL;
|
||||
ret = inflateInit2(&strm, -15); /* raw inflate */
|
||||
if (ret != Z_OK)
|
||||
return ret;
|
||||
ret = fseeko(in, here->in - (here->bits ? 1 : 0), SEEK_SET);
|
||||
if (ret == -1)
|
||||
goto extract_ret;
|
||||
if (here->bits) {
|
||||
ret = getc(in);
|
||||
if (ret == -1) {
|
||||
ret = ferror(in) ? Z_ERRNO : Z_DATA_ERROR;
|
||||
goto extract_ret;
|
||||
}
|
||||
(void)inflatePrime(&strm, here->bits, ret >> (8 - here->bits));
|
||||
}
|
||||
(void)inflateSetDictionary(&strm, here->window, WINSIZE);
|
||||
|
||||
/* skip uncompressed bytes until offset reached, then satisfy request */
|
||||
offset -= here->out;
|
||||
strm.avail_in = 0;
|
||||
skip = 1; /* while skipping to offset */
|
||||
do {
|
||||
/* define where to put uncompressed data, and how much */
|
||||
if (offset == 0 && skip) { /* at offset now */
|
||||
strm.avail_out = len;
|
||||
strm.next_out = buf;
|
||||
skip = 0; /* only do this once */
|
||||
}
|
||||
if (offset > WINSIZE) { /* skip WINSIZE bytes */
|
||||
strm.avail_out = WINSIZE;
|
||||
strm.next_out = discard;
|
||||
offset -= WINSIZE;
|
||||
}
|
||||
else if (offset != 0) { /* last skip */
|
||||
strm.avail_out = (unsigned)offset;
|
||||
strm.next_out = discard;
|
||||
offset = 0;
|
||||
}
|
||||
|
||||
/* uncompress until avail_out filled, or end of stream */
|
||||
do {
|
||||
if (strm.avail_in == 0) {
|
||||
strm.avail_in = fread(input, 1, CHUNK, in);
|
||||
if (ferror(in)) {
|
||||
ret = Z_ERRNO;
|
||||
goto extract_ret;
|
||||
}
|
||||
if (strm.avail_in == 0) {
|
||||
ret = Z_DATA_ERROR;
|
||||
goto extract_ret;
|
||||
}
|
||||
strm.next_in = input;
|
||||
}
|
||||
ret = inflate(&strm, Z_NO_FLUSH); /* normal inflate */
|
||||
if (ret == Z_NEED_DICT)
|
||||
ret = Z_DATA_ERROR;
|
||||
if (ret == Z_MEM_ERROR || ret == Z_DATA_ERROR)
|
||||
goto extract_ret;
|
||||
if (ret == Z_STREAM_END)
|
||||
break;
|
||||
} while (strm.avail_out != 0);
|
||||
|
||||
/* if reach end of stream, then don't keep trying to get more */
|
||||
if (ret == Z_STREAM_END)
|
||||
break;
|
||||
|
||||
/* do until offset reached and requested data read, or stream ends */
|
||||
} while (skip);
|
||||
|
||||
/* compute number of uncompressed bytes read after offset */
|
||||
ret = skip ? 0 : len - strm.avail_out;
|
||||
|
||||
/* clean up and return bytes read or error */
|
||||
extract_ret:
|
||||
(void)inflateEnd(&strm);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Demonstrate the use of build_index() and extract() by processing the file
|
||||
provided on the command line, and the extracting 16K from about 2/3rds of
|
||||
the way through the uncompressed output, and writing that to stdout. */
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int len;
|
||||
off_t offset;
|
||||
FILE *in;
|
||||
struct access *index;
|
||||
unsigned char buf[CHUNK];
|
||||
|
||||
/* open input file */
|
||||
if (argc != 2) {
|
||||
fprintf(stderr, "usage: zran file.gz\n");
|
||||
return 1;
|
||||
}
|
||||
in = fopen(argv[1], "rb");
|
||||
if (in == NULL) {
|
||||
fprintf(stderr, "zran: could not open %s for reading\n", argv[1]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* build index */
|
||||
len = build_index(in, SPAN, &index);
|
||||
if (len < 0) {
|
||||
fclose(in);
|
||||
switch (len) {
|
||||
case Z_MEM_ERROR:
|
||||
fprintf(stderr, "zran: out of memory\n");
|
||||
break;
|
||||
case Z_DATA_ERROR:
|
||||
fprintf(stderr, "zran: compressed data error in %s\n", argv[1]);
|
||||
break;
|
||||
case Z_ERRNO:
|
||||
fprintf(stderr, "zran: read error on %s\n", argv[1]);
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "zran: error %d while building index\n", len);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
fprintf(stderr, "zran: built index with %d access points\n", len);
|
||||
|
||||
/* use index by reading some bytes from an arbitrary offset */
|
||||
offset = (index->list[index->have - 1].out << 1) / 3;
|
||||
len = extract(in, index, offset, buf, CHUNK);
|
||||
if (len < 0)
|
||||
fprintf(stderr, "zran: extraction failed: %s error\n",
|
||||
len == Z_MEM_ERROR ? "out of memory" : "input corrupted");
|
||||
else {
|
||||
fwrite(buf, 1, len, stdout);
|
||||
fprintf(stderr, "zran: extracted %d bytes at %llu\n", len, offset);
|
||||
}
|
||||
|
||||
/* clean up and exit */
|
||||
free_index(index);
|
||||
fclose(in);
|
||||
return 0;
|
||||
}
|
||||
7
gzio.c
7
gzio.c
@ -489,6 +489,9 @@ int ZEXPORT gzread (file, buf, len)
|
||||
}
|
||||
s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start));
|
||||
|
||||
if (len == s->stream.avail_out &&
|
||||
(s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO))
|
||||
return -1;
|
||||
return (int)(len - s->stream.avail_out);
|
||||
}
|
||||
|
||||
@ -975,9 +978,9 @@ int ZEXPORT gzclose (file)
|
||||
#endif
|
||||
|
||||
/* ===========================================================================
|
||||
Returns the error message for the last error which occured on the
|
||||
Returns the error message for the last error which occurred on the
|
||||
given compressed file. errnum is set to zlib error number. If an
|
||||
error occured in the file system and not in the compression library,
|
||||
error occurred in the file system and not in the compression library,
|
||||
errnum is set to Z_ERRNO and the application may consult errno
|
||||
to get the exact error code.
|
||||
*/
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/* infback.c -- inflate using a call-back interface
|
||||
* Copyright (C) 1995-2004 Mark Adler
|
||||
* Copyright (C) 1995-2005 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
@ -50,7 +50,7 @@ int stream_size;
|
||||
sizeof(struct inflate_state));
|
||||
if (state == Z_NULL) return Z_MEM_ERROR;
|
||||
Tracev((stderr, "inflate: allocated\n"));
|
||||
strm->state = (voidpf)state;
|
||||
strm->state = (struct internal_state FAR *)state;
|
||||
state->dmax = 32768U;
|
||||
state->wbits = windowBits;
|
||||
state->wsize = 1U << windowBits;
|
||||
|
||||
31
inflate.c
31
inflate.c
@ -117,6 +117,7 @@ z_streamp strm;
|
||||
state->head = Z_NULL;
|
||||
state->wsize = 0;
|
||||
state->whave = 0;
|
||||
state->write = 0;
|
||||
state->hold = 0;
|
||||
state->bits = 0;
|
||||
state->lencode = state->distcode = state->next = state->codes;
|
||||
@ -124,6 +125,22 @@ z_streamp strm;
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
int ZEXPORT inflatePrime(strm, bits, value)
|
||||
z_streamp strm;
|
||||
int bits;
|
||||
int value;
|
||||
{
|
||||
struct inflate_state FAR *state;
|
||||
|
||||
if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR;
|
||||
value &= (1L << bits) - 1;
|
||||
state->hold += value << state->bits;
|
||||
state->bits += bits;
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
|
||||
z_streamp strm;
|
||||
int windowBits;
|
||||
@ -146,7 +163,7 @@ int stream_size;
|
||||
ZALLOC(strm, 1, sizeof(struct inflate_state));
|
||||
if (state == Z_NULL) return Z_MEM_ERROR;
|
||||
Tracev((stderr, "inflate: allocated\n"));
|
||||
strm->state = (voidpf)state;
|
||||
strm->state = (struct internal_state FAR *)state;
|
||||
if (windowBits < 0) {
|
||||
state->wrap = 0;
|
||||
windowBits = -windowBits;
|
||||
@ -1310,6 +1327,7 @@ z_streamp source;
|
||||
struct inflate_state FAR *state;
|
||||
struct inflate_state FAR *copy;
|
||||
unsigned char FAR *window;
|
||||
unsigned wsize;
|
||||
|
||||
/* check input */
|
||||
if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL ||
|
||||
@ -1335,15 +1353,16 @@ z_streamp source;
|
||||
zmemcpy(dest, source, sizeof(z_stream));
|
||||
zmemcpy(copy, state, sizeof(struct inflate_state));
|
||||
if (state->lencode >= state->codes &&
|
||||
state->lencode <= state->codes + ENOUGH - 1)
|
||||
{
|
||||
state->lencode <= state->codes + ENOUGH - 1) {
|
||||
copy->lencode = copy->codes + (state->lencode - state->codes);
|
||||
copy->distcode = copy->codes + (state->distcode - state->codes);
|
||||
}
|
||||
copy->next = copy->codes + (state->next - state->codes);
|
||||
if (window != Z_NULL)
|
||||
zmemcpy(window, state->window, (uInt)(1U << state->wbits));
|
||||
if (window != Z_NULL) {
|
||||
wsize = 1U << state->wbits;
|
||||
zmemcpy(window, state->window, wsize);
|
||||
}
|
||||
copy->window = window;
|
||||
dest->state = (voidpf)copy;
|
||||
dest->state = (struct internal_state FAR *)copy;
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
#define MAXBITS 15
|
||||
|
||||
const char inflate_copyright[] =
|
||||
" inflate 1.2.2.3 Copyright 1995-2005 Mark Adler ";
|
||||
" inflate 1.2.2.4 Copyright 1995-2005 Mark Adler ";
|
||||
/*
|
||||
If you use the zlib library in a product, an acknowledgment is welcome
|
||||
in the documentation of your product. If for some reason you cannot
|
||||
@ -62,7 +62,7 @@ unsigned short FAR *work;
|
||||
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, 66, 71};
|
||||
19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 206, 69};
|
||||
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,
|
||||
@ -134,7 +134,7 @@ unsigned short FAR *work;
|
||||
left -= count[len];
|
||||
if (left < 0) return -1; /* over-subscribed */
|
||||
}
|
||||
if (left > 0 && (type == CODES || (codes - count[0] != 1)))
|
||||
if (left > 0 && (type == CODES || max != 1))
|
||||
return -1; /* incomplete set */
|
||||
|
||||
/* generate offsets into symbol table for each length for sorting */
|
||||
@ -232,6 +232,7 @@ unsigned short FAR *work;
|
||||
/* replicate for those indices with low len bits equal to huff */
|
||||
incr = 1U << (len - drop);
|
||||
fill = 1U << curr;
|
||||
min = fill; /* save offset to next table */
|
||||
do {
|
||||
fill -= incr;
|
||||
next[(huff >> drop) + fill] = this;
|
||||
@ -262,7 +263,7 @@ unsigned short FAR *work;
|
||||
drop = root;
|
||||
|
||||
/* increment past last table */
|
||||
next += (unsigned)(1U << curr);
|
||||
next += min; /* here min is 1 << curr */
|
||||
|
||||
/* determine length of next table */
|
||||
curr = len - drop;
|
||||
|
||||
10
inftrees.h
10
inftrees.h
@ -1,5 +1,5 @@
|
||||
/* inftrees.h -- header to use inftrees.c
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* Copyright (C) 1995-2005 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
@ -36,12 +36,12 @@ typedef struct {
|
||||
*/
|
||||
|
||||
/* Maximum size of dynamic tree. The maximum found in a long but non-
|
||||
exhaustive search was 1004 code structures (850 for length/literals
|
||||
and 154 for distances, the latter actually the result of an
|
||||
exhaustive search was 1444 code structures (852 for length/literals
|
||||
and 592 for distances, the latter actually the result of an
|
||||
exhaustive search). The true maximum is not known, but the value
|
||||
below is more than safe. */
|
||||
#define ENOUGH 1440
|
||||
#define MAXD 154
|
||||
#define ENOUGH 2048
|
||||
#define MAXD 592
|
||||
|
||||
/* Type of code to build for inftable() */
|
||||
typedef enum {
|
||||
|
||||
407
make_vms.com
407
make_vms.com
@ -1,30 +1,69 @@
|
||||
$! make libz under VMS
|
||||
$! written by Martin P.J. Zinser <m.zinser@gsi.de>
|
||||
$! make libz under VMS written by
|
||||
$! Martin P.J. Zinser
|
||||
$! <zinser@zinser.no-ip.info or zinser@sysdev.deutsche-boerse.com>
|
||||
$!
|
||||
$ on error then goto err_exit
|
||||
$!
|
||||
$!
|
||||
$! Just some general constants...
|
||||
$!
|
||||
$ true = 1
|
||||
$ false = 0
|
||||
$ tmpnam = "temp_" + f$getjpi("","pid")
|
||||
$ SAY = "WRITE SYS$OUTPUT"
|
||||
$!
|
||||
$! Setup variables holding "config" information
|
||||
$!
|
||||
$ Make = ""
|
||||
$ name = "Zlib"
|
||||
$ version = "?.?.?"
|
||||
$ v_string = "ZLIB_VERSION"
|
||||
$ v_file = "zlib.h"
|
||||
$ ccopt = ""
|
||||
$ lopts = ""
|
||||
$ linkonly = false
|
||||
$ optfile = name + ".opt"
|
||||
$ its_decc = false
|
||||
$ its_vaxc = false
|
||||
$ its_gnuc = false
|
||||
$ axp = f$getsyi("HW_MODEL").ge.1024
|
||||
$ s_case = false
|
||||
$! Check for MMK/MMS
|
||||
$!
|
||||
$ If F$Search ("Sys$System:MMS.EXE") .nes. "" Then Make = "MMS"
|
||||
$ If F$Type (MMK) .eqs. "STRING" Then Make = "MMK"
|
||||
$!
|
||||
$!
|
||||
$ gosub find_version
|
||||
$!
|
||||
$ gosub check_opts
|
||||
$!
|
||||
$! Look for the compiler used
|
||||
$!
|
||||
$ ccopt = ""
|
||||
$ if f$getsyi("HW_MODEL").ge.1024
|
||||
$ gosub check_compiler
|
||||
$ if its_decc
|
||||
$ then
|
||||
$ ccopt = "/prefix=all"+ccopt
|
||||
$ comp = "__decc__=1"
|
||||
$ if f$trnlnm("SYS").eqs."" then define sys sys$library:
|
||||
$ else
|
||||
$ if f$search("SYS$SYSTEM:DECC$COMPILER.EXE").eqs.""
|
||||
$ ccopt = "/prefix=all" + ccopt
|
||||
$ if f$trnlnm("SYS") .eqs. ""
|
||||
$ then
|
||||
$ comp = "__vaxc__=1"
|
||||
$ if axp
|
||||
$ then
|
||||
$ define sys sys$library:
|
||||
$ else
|
||||
$ ccopt = "/decc" + ccopt
|
||||
$ define sys decc$library_include:
|
||||
$ endif
|
||||
$ endif
|
||||
$ endif
|
||||
$ if its_vaxc .or. its_gnuc
|
||||
$ then
|
||||
$ if f$trnlnm("SYS").eqs."" then define sys sys$library:
|
||||
$ else
|
||||
$ if f$trnlnm("SYS").eqs."" then define sys decc$library_include:
|
||||
$ ccopt = "/decc/prefix=all"+ccopt
|
||||
$ comp = "__decc__=1"
|
||||
$ endif
|
||||
$ endif
|
||||
$!
|
||||
$! Build the thing plain or with mms
|
||||
$!
|
||||
$ write sys$output "Compiling Zlib sources ..."
|
||||
$ if f$search("SYS$SYSTEM:MMS.EXE").eqs.""
|
||||
$ if make.eqs.""
|
||||
$ then
|
||||
$ dele example.obj;*,minigzip.obj;*
|
||||
$ CALL MAKE adler32.OBJ "CC ''CCOPT' adler32" -
|
||||
@ -32,24 +71,21 @@ $ CALL MAKE adler32.OBJ "CC ''CCOPT' adler32" -
|
||||
$ CALL MAKE compress.OBJ "CC ''CCOPT' compress" -
|
||||
compress.c zlib.h zconf.h
|
||||
$ CALL MAKE crc32.OBJ "CC ''CCOPT' crc32" -
|
||||
crc32.c crc32.h zlib.h zconf.h zutil.h
|
||||
crc32.c zlib.h zconf.h
|
||||
$ CALL MAKE deflate.OBJ "CC ''CCOPT' deflate" -
|
||||
deflate.c deflate.h zutil.h zlib.h zconf.h
|
||||
$ CALL MAKE gzio.OBJ "CC ''CCOPT' gzio /define=""NO_vsnprintf""" -
|
||||
$ CALL MAKE gzio.OBJ "CC ''CCOPT' gzio" -
|
||||
gzio.c zutil.h zlib.h zconf.h
|
||||
$ CALL MAKE infback.OBJ "CC ''CCOPT' infback" -
|
||||
infback.c zutil.h zlib.h zconf.h -
|
||||
"inftrees.h inflate.h inffast.h inffixed.h"
|
||||
infback.c zutil.h inftrees.h inflate.h inffast.h inffixed.h
|
||||
$ CALL MAKE inffast.OBJ "CC ''CCOPT' inffast" -
|
||||
inffast.c zutil.h zlib.h zconf.h -
|
||||
"inftrees.h inflate.h inffast.h"
|
||||
inffast.c zutil.h zlib.h zconf.h inffast.h
|
||||
$ CALL MAKE inflate.OBJ "CC ''CCOPT' inflate" -
|
||||
inflate.c zutil.h zlib.h zconf.h -
|
||||
"inftrees.h inflate.h inffast.h inffixed.h"
|
||||
inflate.c zutil.h zlib.h zconf.h infblock.h
|
||||
$ CALL MAKE inftrees.OBJ "CC ''CCOPT' inftrees" -
|
||||
inftrees.c zutil.h zlib.h zconf.h inftrees.h
|
||||
$ CALL MAKE trees.OBJ "CC ''CCOPT' trees" -
|
||||
trees.c trees.h deflate.h zutil.h zlib.h zconf.h
|
||||
trees.c deflate.h zutil.h zlib.h zconf.h
|
||||
$ CALL MAKE uncompr.OBJ "CC ''CCOPT' uncompr" -
|
||||
uncompr.c zlib.h zconf.h
|
||||
$ CALL MAKE zutil.OBJ "CC ''CCOPT' zutil" -
|
||||
@ -60,17 +96,45 @@ $ write sys$output "Building example..."
|
||||
$ CALL MAKE example.OBJ "CC ''CCOPT' example" -
|
||||
example.c zlib.h zconf.h
|
||||
$ call make example.exe "LINK example,libz.olb/lib" example.obj libz.olb
|
||||
$ write sys$output "Building minigzip..."
|
||||
$ CALL MAKE minigzip.OBJ "CC ''CCOPT' minigzip" -
|
||||
$ if f$search("x11vms:xvmsutils.olb") .nes. ""
|
||||
$ then
|
||||
$ write sys$output "Building minigzip..."
|
||||
$ CALL MAKE minigzip.OBJ "CC ''CCOPT' minigzip" -
|
||||
minigzip.c zlib.h zconf.h
|
||||
$ call make minigzip.exe -
|
||||
"LINK minigzip,libz.olb/lib" -
|
||||
$ call make minigzip.exe -
|
||||
"LINK minigzip,libz.olb/lib,x11vms:xvmsutils.olb/lib" -
|
||||
minigzip.obj libz.olb
|
||||
$ endif
|
||||
$ else
|
||||
$ mms/macro=('comp')
|
||||
$ gosub crea_mms
|
||||
$ SAY "Make ''name' ''version' with ''Make' "
|
||||
$ 'make'
|
||||
$ endif
|
||||
$!
|
||||
$! Alpha gets a shareable image
|
||||
$!
|
||||
$ If axp
|
||||
$ Then
|
||||
$ gosub crea_olist
|
||||
$ write sys$output "Creating libzshr.exe"
|
||||
$ call anal_obj_axp modules.opt _link.opt
|
||||
$ if s_case
|
||||
$ then
|
||||
$ open/append optf modules.opt
|
||||
$ write optf "case_sensitive=YES"
|
||||
$ close optf
|
||||
$ endif
|
||||
$ LINK_'lopts'/SHARE=libzshr.exe modules.opt/opt,_link.opt/opt
|
||||
$ endif
|
||||
$ write sys$output "Zlib build completed"
|
||||
$ exit
|
||||
$CC_ERR:
|
||||
$ write sys$output "C compiler required to build ''name'"
|
||||
$ goto err_exit
|
||||
$ERR_EXIT:
|
||||
$ set message/facil/ident/sever/text
|
||||
$ write sys$output "Exiting..."
|
||||
$ exit 2
|
||||
$!
|
||||
$!
|
||||
$MAKE: SUBROUTINE !SUBROUTINE TO CHECK DEPENDENCIES
|
||||
@ -112,3 +176,286 @@ $ VV='F$Verify(VV)
|
||||
$Exit:
|
||||
$ If V Then Set Verify
|
||||
$ENDSUBROUTINE
|
||||
$!------------------------------------------------------------------------------
|
||||
$!
|
||||
$! Check command line options and set symbols accordingly
|
||||
$!
|
||||
$ CHECK_OPTS:
|
||||
$ i = 1
|
||||
$ OPT_LOOP:
|
||||
$ if i .lt. 9
|
||||
$ then
|
||||
$ cparm = f$edit(p'i',"upcase")
|
||||
$ if cparm .eqs. "DEBUG"
|
||||
$ then
|
||||
$ ccopt = ccopt + "/noopt/deb"
|
||||
$ lopts = lopts + "/deb"
|
||||
$ endif
|
||||
$ if f$locate("CCOPT=",cparm) .lt. f$length(cparm)
|
||||
$ then
|
||||
$ start = f$locate("=",cparm) + 1
|
||||
$ len = f$length(cparm) - start
|
||||
$ ccopt = ccopt + f$extract(start,len,cparm)
|
||||
$ if f$locate("AS_IS",f$edit(ccopt,"UPCASE")) .lt. f$length(ccopt) -
|
||||
then s_case = true
|
||||
$ endif
|
||||
$ if cparm .eqs. "LINK" then linkonly = true
|
||||
$ if f$locate("LOPTS=",cparm) .lt. f$length(cparm)
|
||||
$ then
|
||||
$ start = f$locate("=",cparm) + 1
|
||||
$ len = f$length(cparm) - start
|
||||
$ lopts = lopts + f$extract(start,len,cparm)
|
||||
$ endif
|
||||
$ if f$locate("CC=",cparm) .lt. f$length(cparm)
|
||||
$ then
|
||||
$ start = f$locate("=",cparm) + 1
|
||||
$ len = f$length(cparm) - start
|
||||
$ cc_com = f$extract(start,len,cparm)
|
||||
if (cc_com .nes. "DECC") .and. -
|
||||
(cc_com .nes. "VAXC") .and. -
|
||||
(cc_com .nes. "GNUC")
|
||||
$ then
|
||||
$ write sys$output "Unsupported compiler choice ''cc_com' ignored"
|
||||
$ write sys$output "Use DECC, VAXC, or GNUC instead"
|
||||
$ else
|
||||
$ if cc_com .eqs. "DECC" then its_decc = true
|
||||
$ if cc_com .eqs. "VAXC" then its_vaxc = true
|
||||
$ if cc_com .eqs. "GNUC" then its_gnuc = true
|
||||
$ endif
|
||||
$ endif
|
||||
$ if f$locate("MAKE=",cparm) .lt. f$length(cparm)
|
||||
$ then
|
||||
$ start = f$locate("=",cparm) + 1
|
||||
$ len = f$length(cparm) - start
|
||||
$ mmks = f$extract(start,len,cparm)
|
||||
$ if (mmks .eqs. "MMK") .or. (mmks .eqs. "MMS")
|
||||
$ then
|
||||
$ make = mmks
|
||||
$ else
|
||||
$ write sys$output "Unsupported make choice ''mmks' ignored"
|
||||
$ write sys$output "Use MMK or MMS instead"
|
||||
$ endif
|
||||
$ endif
|
||||
$ i = i + 1
|
||||
$ goto opt_loop
|
||||
$ endif
|
||||
$ return
|
||||
$!------------------------------------------------------------------------------
|
||||
$!
|
||||
$! Look for the compiler used
|
||||
$!
|
||||
$CHECK_COMPILER:
|
||||
$ if (.not. (its_decc .or. its_vaxc .or. its_gnuc))
|
||||
$ then
|
||||
$ its_decc = (f$search("SYS$SYSTEM:DECC$COMPILER.EXE") .nes. "")
|
||||
$ its_vaxc = .not. its_decc .and. (F$Search("SYS$System:VAXC.Exe") .nes. "")
|
||||
$ its_gnuc = .not. (its_decc .or. its_vaxc) .and. (f$trnlnm("gnu_cc") .nes. "")
|
||||
$ endif
|
||||
$!
|
||||
$! Exit if no compiler available
|
||||
$!
|
||||
$ if (.not. (its_decc .or. its_vaxc .or. its_gnuc))
|
||||
$ then goto CC_ERR
|
||||
$ else
|
||||
$ if its_decc then write sys$output "CC compiler check ... Compaq C"
|
||||
$ if its_vaxc then write sys$output "CC compiler check ... VAX C"
|
||||
$ if its_gnuc then write sys$output "CC compiler check ... GNU C"
|
||||
$ endif
|
||||
$ return
|
||||
$!------------------------------------------------------------------------------
|
||||
$!
|
||||
$! If MMS/MMK are available dump out the descrip.mms if required
|
||||
$!
|
||||
$CREA_MMS:
|
||||
$ write sys$output "Creating descrip.mms..."
|
||||
$ create descrip.mms
|
||||
$ open/append out descrip.mms
|
||||
$ copy sys$input: out
|
||||
$ deck
|
||||
# descrip.mms: MMS description file for building zlib on VMS
|
||||
# written by Martin P.J. Zinser
|
||||
# <zinser@zinser.no-ip.info or zinser@sysdev.deutsche-boerse.com>
|
||||
|
||||
OBJS = adler32.obj, compress.obj, crc32.obj, gzio.obj, uncompr.obj, infback.obj\
|
||||
deflate.obj, trees.obj, zutil.obj, inflate.obj, \
|
||||
inftrees.obj, inffast.obj
|
||||
|
||||
$ eod
|
||||
$ write out "CFLAGS=", ccopt
|
||||
$ write out "LOPTS=", lopts
|
||||
$ copy sys$input: out
|
||||
$ deck
|
||||
|
||||
all : example.exe minigzip.exe libz.olb
|
||||
@ write sys$output " Example applications available"
|
||||
|
||||
libz.olb : libz.olb($(OBJS))
|
||||
@ write sys$output " libz available"
|
||||
|
||||
example.exe : example.obj libz.olb
|
||||
link $(LOPTS) example,libz.olb/lib
|
||||
|
||||
minigzip.exe : minigzip.obj libz.olb
|
||||
link $(LOPTS) minigzip,libz.olb/lib,x11vms:xvmsutils.olb/lib
|
||||
|
||||
clean :
|
||||
delete *.obj;*,libz.olb;*,*.opt;*,*.exe;*
|
||||
|
||||
|
||||
# Other dependencies.
|
||||
adler32.obj : adler32.c zutil.h zlib.h zconf.h
|
||||
compress.obj : compress.c zlib.h zconf.h
|
||||
crc32.obj : crc32.c zutil.h zlib.h zconf.h
|
||||
deflate.obj : deflate.c deflate.h zutil.h zlib.h zconf.h
|
||||
example.obj : example.c zlib.h zconf.h
|
||||
gzio.obj : gzio.c zutil.h zlib.h zconf.h
|
||||
inffast.obj : inffast.c zutil.h zlib.h zconf.h inftrees.h inffast.h
|
||||
inflate.obj : inflate.c zutil.h zlib.h zconf.h
|
||||
inftrees.obj : inftrees.c zutil.h zlib.h zconf.h inftrees.h
|
||||
minigzip.obj : minigzip.c zlib.h zconf.h
|
||||
trees.obj : trees.c deflate.h zutil.h zlib.h zconf.h
|
||||
uncompr.obj : uncompr.c zlib.h zconf.h
|
||||
zutil.obj : zutil.c zutil.h zlib.h zconf.h
|
||||
infback.obj : infback.c zutil.h inftrees.h inflate.h inffast.h inffixed.h
|
||||
$ eod
|
||||
$ close out
|
||||
$ return
|
||||
$!------------------------------------------------------------------------------
|
||||
$!
|
||||
$! Read list of core library sources from makefile.in and create options
|
||||
$! needed to build shareable image
|
||||
$!
|
||||
$CREA_OLIST:
|
||||
$ open/read min makefile.in
|
||||
$ open/write mod modules.opt
|
||||
$ src_check = "OBJS ="
|
||||
$MRLOOP:
|
||||
$ read/end=mrdone min rec
|
||||
$ if (f$extract(0,6,rec) .nes. src_check) then goto mrloop
|
||||
$ rec = rec - src_check
|
||||
$ gosub extra_filnam
|
||||
$ if (f$element(1,"\",rec) .eqs. "\") then goto mrdone
|
||||
$MRSLOOP:
|
||||
$ read/end=mrdone min rec
|
||||
$ gosub extra_filnam
|
||||
$ if (f$element(1,"\",rec) .nes. "\") then goto mrsloop
|
||||
$MRDONE:
|
||||
$ close min
|
||||
$ close mod
|
||||
$ return
|
||||
$!------------------------------------------------------------------------------
|
||||
$!
|
||||
$! Take record extracted in crea_olist and split it into single filenames
|
||||
$!
|
||||
$EXTRA_FILNAM:
|
||||
$ myrec = f$edit(rec - "\", "trim,compress")
|
||||
$ i = 0
|
||||
$FELOOP:
|
||||
$ srcfil = f$element(i," ", myrec)
|
||||
$ if (srcfil .nes. " ")
|
||||
$ then
|
||||
$ write mod f$parse(srcfil,,,"NAME"), ".obj"
|
||||
$ i = i + 1
|
||||
$ goto feloop
|
||||
$ endif
|
||||
$ return
|
||||
$!------------------------------------------------------------------------------
|
||||
$!
|
||||
$! Find current Zlib version number
|
||||
$!
|
||||
$FIND_VERSION:
|
||||
$ open/read h_in 'v_file'
|
||||
$hloop:
|
||||
$ read/end=hdone h_in rec
|
||||
$ rec = f$edit(rec,"TRIM")
|
||||
$ if (f$extract(0,1,rec) .nes. "#") then goto hloop
|
||||
$ rec = f$edit(rec - "#", "TRIM")
|
||||
$ if f$element(0," ",rec) .nes. "define" then goto hloop
|
||||
$ if f$element(1," ",rec) .eqs. v_string
|
||||
$ then
|
||||
$ version = 'f$element(2," ",rec)'
|
||||
$ goto hdone
|
||||
$ endif
|
||||
$ goto hloop
|
||||
$hdone:
|
||||
$ close h_in
|
||||
$ return
|
||||
$!------------------------------------------------------------------------------
|
||||
$!
|
||||
$! Analyze Object files for OpenVMS AXP to extract Procedure and Data
|
||||
$! information to build a symbol vector for a shareable image
|
||||
$! All the "brains" of this logic was suggested by Hartmut Becker
|
||||
$! (Hartmut.Becker@compaq.com). All the bugs were introduced by me
|
||||
$! (zinser@decus.de), so if you do have problem reports please do not
|
||||
$! bother Hartmut/HP, but get in touch with me
|
||||
$!
|
||||
$ ANAL_OBJ_AXP: Subroutine
|
||||
$ V = 'F$Verify(0)
|
||||
$ SAY := "WRITE_ SYS$OUTPUT"
|
||||
$
|
||||
$ IF F$SEARCH("''P1'") .EQS. ""
|
||||
$ THEN
|
||||
$ SAY "ANAL_OBJ_AXP-E-NOSUCHFILE: Error, inputfile ''p1' not available"
|
||||
$ goto exit_aa
|
||||
$ ENDIF
|
||||
$ IF "''P2'" .EQS. ""
|
||||
$ THEN
|
||||
$ SAY "ANAL_OBJ_AXP: Error, no output file provided"
|
||||
$ goto exit_aa
|
||||
$ ENDIF
|
||||
$
|
||||
$ open/read in 'p1
|
||||
$ create a.tmp
|
||||
$ open/append atmp a.tmp
|
||||
$ loop:
|
||||
$ read/end=end_loop in line
|
||||
$ f= f$search(line)
|
||||
$ if f .eqs. ""
|
||||
$ then
|
||||
$ write sys$output "ANAL_OBJ_AXP-w-nosuchfile, ''line'"
|
||||
$ goto loop
|
||||
$ endif
|
||||
$ define/user sys$output nl:
|
||||
$ define/user sys$error nl:
|
||||
$ anal/obj/gsd 'f /out=x.tmp
|
||||
$ open/read xtmp x.tmp
|
||||
$ XLOOP:
|
||||
$ read/end=end_xloop xtmp xline
|
||||
$ xline = f$edit(xline,"compress")
|
||||
$ write atmp xline
|
||||
$ goto xloop
|
||||
$ END_XLOOP:
|
||||
$ close xtmp
|
||||
$ goto loop
|
||||
$ end_loop:
|
||||
$ close in
|
||||
$ close atmp
|
||||
$ if f$search("a.tmp") .eqs. "" -
|
||||
then $ exit
|
||||
$ ! all global definitions
|
||||
$ search a.tmp "symbol:","EGSY$V_DEF 1","EGSY$V_NORM 1"/out=b.tmp
|
||||
$ ! all procedures
|
||||
$ search b.tmp "EGSY$V_NORM 1"/wind=(0,1) /out=c.tmp
|
||||
$ search c.tmp "symbol:"/out=d.tmp
|
||||
$ define/user sys$output nl:
|
||||
$ edito/edt/command=sys$input d.tmp
|
||||
sub/symbol: "/symbol_vector=(/whole
|
||||
sub/"/=PROCEDURE)/whole
|
||||
exit
|
||||
$ ! all data
|
||||
$ search b.tmp "EGSY$V_DEF 1"/wind=(0,1) /out=e.tmp
|
||||
$ search e.tmp "symbol:"/out=f.tmp
|
||||
$ define/user sys$output nl:
|
||||
$ edito/edt/command=sys$input f.tmp
|
||||
sub/symbol: "/symbol_vector=(/whole
|
||||
sub/"/=DATA)/whole
|
||||
exit
|
||||
$ sort/nodupl d.tmp,f.tmp 'p2'
|
||||
$ delete a.tmp;*,b.tmp;*,c.tmp;*,d.tmp;*,e.tmp;*,f.tmp;*
|
||||
$ if f$search("x.tmp") .nes. "" -
|
||||
then $ delete x.tmp;*
|
||||
$!
|
||||
$ EXIT_AA:
|
||||
$ if V then set verify
|
||||
$ endsubroutine
|
||||
$!------------------------------------------------------------------------------
|
||||
|
||||
@ -25,10 +25,10 @@
|
||||
<QPG:Files>
|
||||
<QPG:Add file="../zconf.h" install="/opt/include/" user="root:sys" permission="644"/>
|
||||
<QPG:Add file="../zlib.h" install="/opt/include/" user="root:sys" permission="644"/>
|
||||
<QPG:Add file="../libz.so.1.2.2.3" install="/opt/lib/" user="root:bin" permission="644"/>
|
||||
<QPG:Add file="libz.so" install="/opt/lib/" component="dev" filetype="symlink" linkto="libz.so.1.2.2.3"/>
|
||||
<QPG:Add file="libz.so.1" install="/opt/lib/" filetype="symlink" linkto="libz.so.1.2.2.3"/>
|
||||
<QPG:Add file="../libz.so.1.2.2.3" install="/opt/lib/" component="slib"/>
|
||||
<QPG:Add file="../libz.so.1.2.2.4" install="/opt/lib/" user="root:bin" permission="644"/>
|
||||
<QPG:Add file="libz.so" install="/opt/lib/" component="dev" filetype="symlink" linkto="libz.so.1.2.2.4"/>
|
||||
<QPG:Add file="libz.so.1" install="/opt/lib/" filetype="symlink" linkto="libz.so.1.2.2.4"/>
|
||||
<QPG:Add file="../libz.so.1.2.2.4" install="/opt/lib/" component="slib"/>
|
||||
</QPG:Files>
|
||||
|
||||
<QPG:PackageFilter>
|
||||
@ -63,7 +63,7 @@
|
||||
</QPM:ProductDescription>
|
||||
|
||||
<QPM:ReleaseDescription>
|
||||
<QPM:ReleaseVersion>1.2.2.3</QPM:ReleaseVersion>
|
||||
<QPM:ReleaseVersion>1.2.2.4</QPM:ReleaseVersion>
|
||||
<QPM:ReleaseUrgency>Medium</QPM:ReleaseUrgency>
|
||||
<QPM:ReleaseStability>Stable</QPM:ReleaseStability>
|
||||
<QPM:ReleaseNoteMinor></QPM:ReleaseNoteMinor>
|
||||
|
||||
4
trees.c
4
trees.c
@ -1,5 +1,5 @@
|
||||
/* trees.c -- output deflated data using Huffman coding
|
||||
* Copyright (C) 1995-2004 Jean-loup Gailly
|
||||
* Copyright (C) 1995-2005 Jean-loup Gailly
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
@ -555,7 +555,7 @@ local void gen_bitlen(s, desc)
|
||||
while (n != 0) {
|
||||
m = s->heap[--h];
|
||||
if (m > max_code) continue;
|
||||
if (tree[m].Len != (unsigned) bits) {
|
||||
if ((unsigned) tree[m].Len != (unsigned) bits) {
|
||||
Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
|
||||
s->opt_len += ((long)bits - (long)tree[m].Len)
|
||||
*(long)tree[m].Freq;
|
||||
|
||||
@ -5,8 +5,8 @@ VS_VERSION_INFO VERSIONINFO
|
||||
#else
|
||||
VS_VERSION_INFO VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE
|
||||
#endif
|
||||
FILEVERSION 1,2,2,3
|
||||
PRODUCTVERSION 1,2,2,3
|
||||
FILEVERSION 1,2,2,4
|
||||
PRODUCTVERSION 1,2,2,4
|
||||
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
|
||||
#ifdef _DEBUG
|
||||
FILEFLAGS 1
|
||||
@ -23,12 +23,12 @@ BEGIN
|
||||
//language ID = U.S. English, char set = Windows, Multilingual
|
||||
BEGIN
|
||||
VALUE "FileDescription", "zlib data compression library\0"
|
||||
VALUE "FileVersion", "1.2.2.3\0"
|
||||
VALUE "FileVersion", "1.2.2.4\0"
|
||||
VALUE "InternalName", "zlib1.dll\0"
|
||||
VALUE "LegalCopyright", "(C) 1995-2004 Jean-loup Gailly & Mark Adler\0"
|
||||
VALUE "OriginalFilename", "zlib1.dll\0"
|
||||
VALUE "ProductName", "zlib\0"
|
||||
VALUE "ProductVersion", "1.2.2.3\0"
|
||||
VALUE "ProductVersion", "1.2.2.4\0"
|
||||
VALUE "Comments","DLL support by Alessandro Iacopetti & Gilles Vollant\0"
|
||||
END
|
||||
END
|
||||
|
||||
6
zlib.3
6
zlib.3
@ -1,4 +1,4 @@
|
||||
.TH ZLIB 3 "27 May 2005"
|
||||
.TH ZLIB 3 "11 July 2005"
|
||||
.SH NAME
|
||||
zlib \- compression/decompression library
|
||||
.SH SYNOPSIS
|
||||
@ -133,8 +133,8 @@ before asking for help.
|
||||
Send questions and/or comments to zlib@gzip.org,
|
||||
or (for the Windows DLL version) to Gilles Vollant (info@winimage.com).
|
||||
.SH AUTHORS
|
||||
Version 1.2.2.3
|
||||
Copyright (C) 1995-2004 Jean-loup Gailly (jloup@gzip.org)
|
||||
Version 1.2.2.4
|
||||
Copyright (C) 1995-2005 Jean-loup Gailly (jloup@gzip.org)
|
||||
and Mark Adler (madler@alumni.caltech.edu).
|
||||
.LP
|
||||
This software is provided "as-is,"
|
||||
|
||||
32
zlib.h
32
zlib.h
@ -1,5 +1,5 @@
|
||||
/* zlib.h -- interface of the 'zlib' general purpose compression library
|
||||
version 1.2.2.3, May 27th, 2005
|
||||
version 1.2.2.4, July 11th, 2005
|
||||
|
||||
Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler
|
||||
|
||||
@ -37,8 +37,8 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define ZLIB_VERSION "1.2.2.3"
|
||||
#define ZLIB_VERNUM 0x1223
|
||||
#define ZLIB_VERSION "1.2.2.4"
|
||||
#define ZLIB_VERNUM 0x1224
|
||||
|
||||
/*
|
||||
The 'zlib' compression library provides in-memory compression and
|
||||
@ -726,11 +726,11 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
|
||||
a crc32 instead of an adler32.
|
||||
|
||||
inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||
memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
|
||||
memLevel). msg is set to null if there is no error message. inflateInit2
|
||||
does not perform any decompression apart from reading the zlib header if
|
||||
present: this will be done by inflate(). (So next_in and avail_in may be
|
||||
modified, but next_out and avail_out are unchanged.)
|
||||
memory, Z_STREAM_ERROR if a parameter is invalid (such as a null strm). msg
|
||||
is set to null if there is no error message. inflateInit2 does not perform
|
||||
any decompression apart from reading the zlib header if present: this will
|
||||
be done by inflate(). (So next_in and avail_in may be modified, but next_out
|
||||
and avail_out are unchanged.)
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
|
||||
@ -796,6 +796,22 @@ ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
|
||||
stream state was inconsistent (such as zalloc or state being NULL).
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
|
||||
int bits,
|
||||
int value));
|
||||
/*
|
||||
This function inserts bits in the inflate input stream. The intent is
|
||||
that this function is used to start inflating at a bit position in the
|
||||
middle of a byte. The provided bits will be used before any bytes are used
|
||||
from next_in. This function should only be used with raw inflate, and
|
||||
should be used before the first inflate() call after inflateInit2() or
|
||||
inflateReset(). bits must be less than or equal to 16, and that many of the
|
||||
least significant bits of value will be inserted in the input.
|
||||
|
||||
inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
|
||||
stream state was inconsistent.
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
|
||||
gz_headerp head));
|
||||
/*
|
||||
|
||||
24
zutil.c
24
zutil.c
@ -1,5 +1,5 @@
|
||||
/* zutil.c -- target dependent utility functions for the compression library
|
||||
* Copyright (C) 1995-2004 Jean-loup Gailly.
|
||||
* Copyright (C) 1995-2005 Jean-loup Gailly.
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
@ -74,38 +74,38 @@ uLong ZEXPORT zlibCompileFlags()
|
||||
flags += 1 << 13;
|
||||
#endif
|
||||
#ifdef NO_GZCOMPRESS
|
||||
flags += 1 << 16;
|
||||
flags += 1L << 16;
|
||||
#endif
|
||||
#ifdef NO_GZIP
|
||||
flags += 1 << 17;
|
||||
flags += 1L << 17;
|
||||
#endif
|
||||
#ifdef PKZIP_BUG_WORKAROUND
|
||||
flags += 1 << 20;
|
||||
flags += 1L << 20;
|
||||
#endif
|
||||
#ifdef FASTEST
|
||||
flags += 1 << 21;
|
||||
flags += 1L << 21;
|
||||
#endif
|
||||
#ifdef STDC
|
||||
# ifdef NO_vsnprintf
|
||||
flags += 1 << 25;
|
||||
flags += 1L << 25;
|
||||
# ifdef HAS_vsprintf_void
|
||||
flags += 1 << 26;
|
||||
flags += 1L << 26;
|
||||
# endif
|
||||
# else
|
||||
# ifdef HAS_vsnprintf_void
|
||||
flags += 1 << 26;
|
||||
flags += 1L << 26;
|
||||
# endif
|
||||
# endif
|
||||
#else
|
||||
flags += 1 << 24;
|
||||
flags += 1L << 24;
|
||||
# ifdef NO_snprintf
|
||||
flags += 1 << 25;
|
||||
flags += 1L << 25;
|
||||
# ifdef HAS_sprintf_void
|
||||
flags += 1 << 26;
|
||||
flags += 1L << 26;
|
||||
# endif
|
||||
# else
|
||||
# ifdef HAS_snprintf_void
|
||||
flags += 1 << 26;
|
||||
flags += 1L << 26;
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
Loading…
Reference in New Issue
Block a user