mirror of https://github.com/madler/zlib.git
Mark Adler
13 years ago
parent
ebd3c2c0e7
commit
7850e4e406
58 changed files with 4613 additions and 524 deletions
@ -0,0 +1,21 @@ |
||||
All files under this contrib directory are UNSUPPORTED. There were |
||||
provided by users of zlib and were not tested by the authors of zlib. |
||||
Use at your own risk. Please contact the authors of the contributions |
||||
for help about these, not the zlib authors. Thanks. |
||||
|
||||
|
||||
asm386/ by Gilles Vollant <info@winimage.com> |
||||
386 asm code replacing longest_match(). This code may be slower |
||||
than the C code if you have a good compiler. |
||||
|
||||
iostream/ by Kevin Ruland <kevin@rodin.wustl.edu> |
||||
A C++ I/O streams interface to the zlib gz* functions |
||||
|
||||
iostream2/ by Tyge Løvset <Tyge.Lovset@cmr.no> |
||||
Another C++ I/O streams interface |
||||
|
||||
untgz/ by "Pedro A. Aranda Guti\irrez" <paag@tid.es> |
||||
A very simple tar.gz file extractor using zlib |
||||
|
||||
visual-basic.txt by Carlos Rios <c_rios@sonda.cl> |
||||
How to use compress(), uncompress() and the gz* functions from VB. |
||||
@ -0,0 +1,464 @@ |
||||
; |
||||
; gvmat32.asm -- Asm portion of the optimized longest_match for 32 bits x86 |
||||
; Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant. |
||||
; File written by Gilles Vollant, by modifiying the longest_match |
||||
; from Jean-loup Gailly in deflate.c |
||||
; It need wmask == 0x7fff |
||||
; (assembly code is faster with a fixed wmask) |
||||
; |
||||
; For Visual C++ 4.2 and ML 6.11c (version in directory \MASM611C of Win95 DDK) |
||||
; I compile with : "ml /coff /Zi /c gvmat32.asm" |
||||
; |
||||
; uInt longest_match_gvasm(IPos cur_match,int* match_start_ptr,uInt scan_end, |
||||
; uInt scan_start,ush* prev,uch* window,int best_len, |
||||
; IPos limit,uInt chain_length,uch* scanrp, |
||||
; uInt nice_match); |
||||
|
||||
;uInt longest_match(s, cur_match) |
||||
; deflate_state *s; |
||||
; IPos cur_match; /* current match */ |
||||
|
||||
NbStack equ 76 |
||||
cur_match equ dword ptr[esp+NbStack-0] |
||||
str_s equ dword ptr[esp+NbStack-4] |
||||
; 5 dword on top (ret,ebp,esi,edi,ebx) |
||||
adrret equ dword ptr[esp+NbStack-8] |
||||
pushebp equ dword ptr[esp+NbStack-12] |
||||
pushedi equ dword ptr[esp+NbStack-16] |
||||
pushesi equ dword ptr[esp+NbStack-20] |
||||
pushebx equ dword ptr[esp+NbStack-24] |
||||
|
||||
chain_length equ dword ptr [esp+NbStack-28] |
||||
limit equ dword ptr [esp+NbStack-32] |
||||
best_len equ dword ptr [esp+NbStack-36] |
||||
window equ dword ptr [esp+NbStack-40] |
||||
prev equ dword ptr [esp+NbStack-44] |
||||
scan_start equ word ptr [esp+NbStack-48] |
||||
scan_end equ word ptr [esp+NbStack-52] |
||||
match_start_ptr equ dword ptr [esp+NbStack-56] |
||||
nice_match equ dword ptr [esp+NbStack-60] |
||||
scanrp equ dword ptr [esp+NbStack-64] |
||||
|
||||
windowlen equ dword ptr [esp+NbStack-68] |
||||
match_start equ dword ptr [esp+NbStack-72] |
||||
strend equ dword ptr [esp+NbStack-76] |
||||
NbStackAdd equ (76-24) |
||||
|
||||
.386p |
||||
|
||||
name gvmatch |
||||
.MODEL FLAT |
||||
|
||||
|
||||
@lmtype TYPEDEF PROTO C :PTR , :SDWORD |
||||
longest_match_c PROTO @lmtype |
||||
|
||||
dep_max_chain_length equ 70h |
||||
dep_window equ 2ch |
||||
dep_strstart equ 60h |
||||
dep_prev_length equ 6ch |
||||
dep_nice_match equ 84h |
||||
dep_w_size equ 20h |
||||
dep_prev equ 34h |
||||
dep_w_mask equ 28h |
||||
dep_good_match equ 80h |
||||
dep_match_start equ 64h |
||||
dep_lookahead equ 68h |
||||
|
||||
|
||||
_TEXT segment |
||||
public _longest_match_asm7fff |
||||
|
||||
MAX_MATCH equ 258 |
||||
MIN_MATCH equ 3 |
||||
MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1) |
||||
|
||||
; initialize or check the variables used in match.asm. |
||||
|
||||
|
||||
; ----------------------------------------------------------------------- |
||||
; Set match_start to the longest match starting at the given string and |
||||
; return its length. Matches shorter or equal to prev_length are discarded, |
||||
; in which case the result is equal to prev_length and match_start is |
||||
; garbage. |
||||
; IN assertions: cur_match is the head of the hash chain for the current |
||||
; string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 |
||||
|
||||
; int longest_match(cur_match) |
||||
|
||||
_longest_match_asm7fff proc near |
||||
|
||||
|
||||
|
||||
; return address |
||||
|
||||
mov eax,[esp+4] |
||||
mov bx,[eax+dep_w_mask] |
||||
cmp bx,7fffh |
||||
jnz longest_match_c |
||||
|
||||
push ebp |
||||
push edi |
||||
push esi |
||||
push ebx |
||||
|
||||
sub esp,NbStackAdd |
||||
|
||||
;//mov ebp,str_s |
||||
mov ebp,eax |
||||
|
||||
mov eax,[ebp+dep_max_chain_length] |
||||
mov ebx,[ebp+dep_prev_length] |
||||
cmp [ebp+dep_good_match],ebx ; if prev_length>=good_match chain_length >>= 2 |
||||
ja noshr |
||||
shr eax,2 |
||||
noshr: |
||||
mov edi,[ebp+dep_nice_match] |
||||
mov chain_length,eax |
||||
mov edx,[ebp+dep_lookahead] |
||||
cmp edx,edi |
||||
;if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; |
||||
jae nolookaheadnicematch |
||||
mov edi,edx |
||||
nolookaheadnicematch: |
||||
mov best_len,ebx |
||||
|
||||
|
||||
mov esi,[ebp+dep_window] |
||||
mov ecx,[ebp+dep_strstart] |
||||
mov window,esi |
||||
|
||||
mov nice_match,edi |
||||
add esi,ecx |
||||
mov scanrp,esi |
||||
mov ax,word ptr [esi] |
||||
mov bx,word ptr [esi+ebx-1] |
||||
add esi,MAX_MATCH-1 |
||||
mov scan_start,ax |
||||
mov strend,esi |
||||
mov scan_end,bx |
||||
|
||||
; IPos limit = s->strstart > (IPos)MAX_DIST(s) ? |
||||
; s->strstart - (IPos)MAX_DIST(s) : NIL; |
||||
|
||||
mov esi,[ebp+dep_w_size] |
||||
sub esi,MIN_LOOKAHEAD |
||||
; here esi = MAX_DIST(s) |
||||
sub ecx,esi |
||||
ja nodist |
||||
xor ecx,ecx |
||||
nodist: |
||||
mov limit,ecx |
||||
|
||||
|
||||
|
||||
|
||||
mov eax,[ebp+dep_prev] |
||||
mov prev,eax |
||||
|
||||
mov ebx,dword ptr [ebp+dep_match_start] |
||||
mov bp,scan_start |
||||
mov edx,cur_match |
||||
mov match_start,ebx |
||||
|
||||
mov bx,scan_end |
||||
mov eax,window |
||||
mov edi,eax |
||||
add edi,best_len |
||||
mov esi,prev |
||||
dec edi |
||||
mov windowlen,edi |
||||
|
||||
jmp beginloop2 |
||||
align 4 |
||||
|
||||
; here, in the loop |
||||
;;;; eax = chain_length |
||||
; edx = dx = cur_match |
||||
; ecx = limit |
||||
; bx = scan_end |
||||
; bp = scan_start |
||||
; edi = windowlen (window + best_len) |
||||
; esi = prev |
||||
|
||||
|
||||
;// here; eax <=16 |
||||
normalbeg0add16: |
||||
add chain_length,16 |
||||
jz exitloop |
||||
normalbeg0: |
||||
cmp word ptr[edi+edx-0],bx |
||||
je normalbeg2 |
||||
and edx,7fffh |
||||
mov dx,word ptr[esi+edx*2] |
||||
cmp ecx,edx |
||||
jnb exitloop |
||||
dec chain_length |
||||
jnz normalbeg0 |
||||
;jnbexitloopshort1: |
||||
jmp exitloop |
||||
|
||||
contloop3: |
||||
mov edi,windowlen |
||||
|
||||
; cur_match = prev[cur_match & wmask] |
||||
and edx,7fffh |
||||
mov dx,word ptr[esi+edx*2] |
||||
; if cur_match > limit, go to exitloop |
||||
cmp ecx,edx |
||||
jnbexitloopshort1: |
||||
jnb exitloop |
||||
; if --chain_length != 0, go to exitloop |
||||
|
||||
beginloop2: |
||||
sub chain_length,16+1 |
||||
jna normalbeg0add16 |
||||
|
||||
do16: |
||||
cmp word ptr[edi+edx],bx |
||||
je normalbeg2dc0 |
||||
|
||||
maccn MACRO lab |
||||
and edx,7fffh |
||||
mov dx,word ptr[esi+edx*2] |
||||
cmp ecx,edx |
||||
jnb exitloop |
||||
cmp word ptr[edi+edx-0],bx |
||||
je lab |
||||
ENDM |
||||
|
||||
rcontloop0: |
||||
maccn normalbeg2dc1 |
||||
|
||||
rcontloop1: |
||||
maccn normalbeg2dc2 |
||||
|
||||
rcontloop2: |
||||
maccn normalbeg2dc3 |
||||
|
||||
rcontloop3: |
||||
maccn normalbeg2dc4 |
||||
|
||||
rcontloop4: |
||||
maccn normalbeg2dc5 |
||||
|
||||
rcontloop5: |
||||
maccn normalbeg2dc6 |
||||
|
||||
rcontloop6: |
||||
maccn normalbeg2dc7 |
||||
|
||||
rcontloop7: |
||||
maccn normalbeg2dc8 |
||||
|
||||
rcontloop8: |
||||
maccn normalbeg2dc9 |
||||
|
||||
rcontloop9: |
||||
maccn normalbeg2dc10 |
||||
|
||||
rcontloop10: |
||||
maccn normalbeg2dc11 |
||||
|
||||
rcontloop11: |
||||
maccn short normalbeg2dc12 |
||||
|
||||
rcontloop12: |
||||
maccn short normalbeg2dc13 |
||||
|
||||
rcontloop13: |
||||
maccn short normalbeg2dc14 |
||||
|
||||
rcontloop14: |
||||
maccn short normalbeg2dc15 |
||||
|
||||
rcontloop15: |
||||
and edx,7fffh |
||||
mov dx,word ptr[esi+edx*2] |
||||
cmp ecx,edx |
||||
jnb short exitloopshort |
||||
|
||||
sub chain_length,16 |
||||
ja do16 |
||||
jmp normalbeg0add16 |
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
||||
|
||||
exitloopshort: |
||||
jmp exitloop |
||||
|
||||
normbeg MACRO rcontlab,valsub |
||||
cmp bp,word ptr[eax+edx] |
||||
jne rcontlab |
||||
add chain_length,16-valsub |
||||
jmp iseq |
||||
ENDM |
||||
|
||||
normalbeg2dc12: |
||||
normbeg rcontloop12,12 |
||||
|
||||
normalbeg2dc13: |
||||
normbeg rcontloop13,13 |
||||
|
||||
normalbeg2dc14: |
||||
normbeg rcontloop14,14 |
||||
|
||||
normalbeg2dc15: |
||||
normbeg rcontloop15,15 |
||||
|
||||
normalbeg2dc11: |
||||
normbeg rcontloop11,11 |
||||
|
||||
normalbeg2dc10: |
||||
normbeg rcontloop10,10 |
||||
|
||||
|
||||
normalbeg2dc9: |
||||
normbeg rcontloop9,9 |
||||
|
||||
normalbeg2dc8: |
||||
normbeg rcontloop8,8 |
||||
|
||||
normalbeg2dc7: |
||||
normbeg rcontloop7,7 |
||||
|
||||
normalbeg2dc5: |
||||
normbeg rcontloop5,5 |
||||
|
||||
|
||||
|
||||
|
||||
|
||||
normalbeg2dc6: |
||||
normbeg rcontloop6,6 |
||||
|
||||
normalbeg2dc4: |
||||
normbeg rcontloop4,4 |
||||
|
||||
normalbeg2dc3: |
||||
normbeg rcontloop3,3 |
||||
|
||||
normalbeg2dc2: |
||||
normbeg rcontloop2,2 |
||||
|
||||
normalbeg2dc1: |
||||
normbeg rcontloop1,1 |
||||
|
||||
normalbeg2dc0: |
||||
normbeg rcontloop0,0 |
||||
|
||||
|
||||
; we go in normalbeg2 because *(ushf*)(match+best_len-1) == scan_end |
||||
|
||||
normalbeg2: |
||||
|
||||
; 10 nop here take 10% time |
||||
mov edi,window |
||||
;mov chain_length,eax ; now, we need eax... |
||||
|
||||
cmp bp,word ptr[edi+edx] |
||||
jne contloop3 ; if *(ushf*)match != scan_start, continue |
||||
|
||||
iseq: |
||||
|
||||
mov edi,eax |
||||
mov esi,scanrp ; esi = scan |
||||
add edi,edx ; edi = window + cur_match = match |
||||
|
||||
|
||||
mov eax,[esi+3] ; compare manually dword at match+3 |
||||
xor eax,[edi+3] ; and scan +3 |
||||
|
||||
jz begincompare ; if equal, go to long compare |
||||
|
||||
; we will determine the unmatch byte and calculate len (in esi) |
||||
or al,al |
||||
je eq1rr |
||||
mov esi,3 |
||||
jmp trfinval |
||||
eq1rr: |
||||
or ax,ax |
||||
je eq1 |
||||
|
||||
mov esi,4 |
||||
jmp trfinval |
||||
eq1: |
||||
shl eax,8 |
||||
jz eq11 |
||||
mov esi,5 |
||||
jmp trfinval |
||||
eq11: |
||||
mov esi,6 |
||||
jmp trfinval |
||||
|
||||
begincompare: |
||||
; here we now scan and match begin same |
||||
add edi,6 |
||||
add esi,6 |
||||
mov ecx,(MAX_MATCH-(2+4))/4 ;//; scan for at most MAX_MATCH bytes |
||||
repe cmpsd ;//; loop until mismatch |
||||
|
||||
je trfin ; go to trfin if not unmatch |
||||
; we determine the unmatch byte |
||||
sub esi,4 |
||||
mov eax,[edi-4] |
||||
xor eax,[esi] |
||||
or al,al |
||||
|
||||
jnz trfin |
||||
inc esi |
||||
|
||||
or ax,ax |
||||
jnz trfin |
||||
inc esi |
||||
|
||||
shl eax,8 |
||||
jnz trfin |
||||
inc esi |
||||
|
||||
trfin: |
||||
sub esi,scanrp ; esi = len |
||||
trfinval: |
||||
cmp esi,best_len ; if len <= best_len, go contloop2 |
||||
jbe contloop2 |
||||
|
||||
mov best_len,esi ; len become best_len |
||||
|
||||
mov match_start,edx |
||||
cmp esi,nice_match ;//; if esi >= nice_match, exit |
||||
mov ecx,scanrp |
||||
jae exitloop |
||||
add esi,window |
||||
add ecx,best_len |
||||
dec esi |
||||
mov windowlen,esi |
||||
mov bx,[ecx-1] |
||||
|
||||
|
||||
; now we restore eax, ecx and esi, for the big loop : |
||||
contloop2: |
||||
mov esi,prev |
||||
mov ecx,limit |
||||
;mov eax,chain_length |
||||
mov eax,window |
||||
jmp contloop3 |
||||
|
||||
exitloop: |
||||
mov ebx,match_start |
||||
mov ebp,str_s |
||||
mov dword ptr [ebp+dep_match_start],ebx |
||||
mov eax,best_len |
||||
add esp,NbStackAdd |
||||
|
||||
|
||||
pop ebx |
||||
pop esi |
||||
pop edi |
||||
pop ebp |
||||
ret |
||||
|
||||
_longest_match_asm7fff endp |
||||
|
||||
_TEXT ends |
||||
end |
||||
|
||||
@ -0,0 +1,229 @@ |
||||
/* gvmat32.c -- C portion of the optimized longest_match for 32 bits x86
|
||||
* Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant. |
||||
* File written by Gilles Vollant, by modifiying the longest_match |
||||
* from Jean-loup Gailly in deflate.c |
||||
* it prepare all parameters and call the assembly longest_match_gvasm |
||||
* longest_match execute standard C code is wmask != 0x7fff |
||||
* (assembly code is faster with a fixed wmask) |
||||
* |
||||
*/ |
||||
//#pragma optimize("agt",on)
|
||||
|
||||
#include "deflate.h" |
||||
|
||||
#undef FAR |
||||
#include <windows.h> |
||||
|
||||
#ifdef ASMV |
||||
|
||||
#define NIL 0 |
||||
|
||||
static unsigned int tot=0; |
||||
static unsigned int totl0=0; |
||||
static unsigned int totl0p0=0; |
||||
static unsigned int ba0=0; |
||||
static unsigned int ba1=0; |
||||
static unsigned int cpta=0; |
||||
static unsigned int cptb=0; |
||||
|
||||
#define UNALIGNED_OK |
||||
#define gvshow(a,b,c,d) |
||||
/*
|
||||
void gvshow(int chain_length,int len,int limit,ushf* prev) |
||||
{ |
||||
static int ival=0; |
||||
char sz[80]; |
||||
unsigned long i; |
||||
int prev0=*prev; |
||||
ival++; |
||||
//wsprintf(sz,"call %u, len=%u, chain_length=%u\n",ival,len,chain_length);
|
||||
//OutputDebugString(sz);
|
||||
tot++; |
||||
if (limit==NIL) |
||||
totl0++; |
||||
if ((limit==NIL) && (prev0==0)) |
||||
totl0p0++; |
||||
for (i=limit+1;i<32768;i++) |
||||
{ |
||||
ush va=*(prev+i); |
||||
if (ba0>4000000000) |
||||
{ |
||||
ba0+=10; |
||||
} |
||||
ba0++; |
||||
if ((va>limit) || (va==0)) |
||||
continue; |
||||
ba1++; |
||||
} |
||||
} |
||||
*/ |
||||
|
||||
|
||||
/* if your C compiler don't add underline before function name,
|
||||
define ADD_UNDERLINE_ASMFUNC */ |
||||
#ifdef ADD_UNDERLINE_ASMFUNC |
||||
#define longest_match_asm7fff _longest_match_asm7fff |
||||
#endif |
||||
void match_init() |
||||
{ |
||||
} |
||||
|
||||
uInt longest_match_c( |
||||
deflate_state *s, |
||||
IPos cur_match); /* current match */ |
||||
|
||||
|
||||
uInt longest_match_asm7fff( |
||||
deflate_state *s, |
||||
IPos cur_match); /* current match */ |
||||
|
||||
uInt longest_match( |
||||
deflate_state *s, |
||||
IPos cur_match) /* current match */ |
||||
{ |
||||
if (s->w_mask == 0x7fff) |
||||
return longest_match_asm7fff(s,cur_match); |
||||
return longest_match_c(s,cur_match); |
||||
} |
||||
|
||||
|
||||
|
||||
uInt longest_match_c(s, cur_match) |
||||
deflate_state *s; |
||||
IPos cur_match; /* current match */ |
||||
{ |
||||
unsigned chain_length = s->max_chain_length;/* max hash chain length */ |
||||
register Bytef *scan = s->window + s->strstart; /* current string */ |
||||
register Bytef *match; /* matched string */ |
||||
register int len; /* length of current match */ |
||||
int best_len = s->prev_length; /* best match length so far */ |
||||
int nice_match = s->nice_match; /* stop if match long enough */ |
||||
IPos limit = s->strstart > (IPos)MAX_DIST(s) ? |
||||
s->strstart - (IPos)MAX_DIST(s) : NIL; |
||||
/* Stop when cur_match becomes <= limit. To simplify the code,
|
||||
* we prevent matches with the string of window index 0. |
||||
*/ |
||||
Posf *prev = s->prev; |
||||
uInt wmask = s->w_mask; |
||||
|
||||
#ifdef UNALIGNED_OK |
||||
/* Compare two bytes at a time. Note: this is not always beneficial.
|
||||
* Try with and without -DUNALIGNED_OK to check. |
||||
*/ |
||||
register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; |
||||
register ush scan_start = *(ushf*)scan; |
||||
register ush scan_end = *(ushf*)(scan+best_len-1); |
||||
#else |
||||
register Bytef *strend = s->window + s->strstart + MAX_MATCH; |
||||
register Byte scan_end1 = scan[best_len-1]; |
||||
register Byte scan_end = scan[best_len]; |
||||
#endif |
||||
|
||||
/* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
|
||||
* It is easy to get rid of this optimization if necessary. |
||||
*/ |
||||
Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); |
||||
|
||||
/* Do not waste too much time if we already have a good match: */ |
||||
if (s->prev_length >= s->good_match) { |
||||
chain_length >>= 2; |
||||
} |
||||
/* Do not look for matches beyond the end of the input. This is necessary
|
||||
* to make deflate deterministic. |
||||
*/ |
||||
if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; |
||||
|
||||
Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); |
||||
|
||||
do { |
||||
Assert(cur_match < s->strstart, "no future"); |
||||
match = s->window + cur_match; |
||||
|
||||
/* Skip to next match if the match length cannot increase
|
||||
* or if the match length is less than 2: |
||||
*/ |
||||
#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) |
||||
/* This code assumes sizeof(unsigned short) == 2. Do not use
|
||||
* UNALIGNED_OK if your compiler uses a different size. |
||||
*/ |
||||
if (*(ushf*)(match+best_len-1) != scan_end || |
||||
*(ushf*)match != scan_start) continue; |
||||
|
||||
/* It is not necessary to compare scan[2] and match[2] since they are
|
||||
* always equal when the other bytes match, given that the hash keys |
||||
* are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at |
||||
* strstart+3, +5, ... up to strstart+257. We check for insufficient |
||||
* lookahead only every 4th comparison; the 128th check will be made |
||||
* at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is |
||||
* necessary to put more guard bytes at the end of the window, or |
||||
* to check more often for insufficient lookahead. |
||||
*/ |
||||
Assert(scan[2] == match[2], "scan[2]?"); |
||||
scan++, match++; |
||||
do { |
||||
} while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && |
||||
*(ushf*)(scan+=2) == *(ushf*)(match+=2) && |
||||
*(ushf*)(scan+=2) == *(ushf*)(match+=2) && |
||||
*(ushf*)(scan+=2) == *(ushf*)(match+=2) && |
||||
scan < strend); |
||||
/* The funny "do {}" generates better code on most compilers */ |
||||
|
||||
/* Here, scan <= window+strstart+257 */ |
||||
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); |
||||
if (*scan == *match) scan++; |
||||
|
||||
len = (MAX_MATCH - 1) - (int)(strend-scan); |
||||
scan = strend - (MAX_MATCH-1); |
||||
|
||||
#else /* UNALIGNED_OK */ |
||||
|
||||
if (match[best_len] != scan_end || |
||||
match[best_len-1] != scan_end1 || |
||||
*match != *scan || |
||||
*++match != scan[1]) continue; |
||||
|
||||
/* The check at best_len-1 can be removed because it will be made
|
||||
* again later. (This heuristic is not always a win.) |
||||
* It is not necessary to compare scan[2] and match[2] since they |
||||
* are always equal when the other bytes match, given that |
||||
* the hash keys are equal and that HASH_BITS >= 8. |
||||
*/ |
||||
scan += 2, match++; |
||||
Assert(*scan == *match, "match[2]?"); |
||||
|
||||
/* We check for insufficient lookahead only every 8th comparison;
|
||||
* the 256th check will be made at strstart+258. |
||||
*/ |
||||
do { |
||||
} while (*++scan == *++match && *++scan == *++match && |
||||
*++scan == *++match && *++scan == *++match && |
||||
*++scan == *++match && *++scan == *++match && |
||||
*++scan == *++match && *++scan == *++match && |
||||
scan < strend); |
||||
|
||||
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); |
||||
|
||||
len = MAX_MATCH - (int)(strend - scan); |
||||
scan = strend - MAX_MATCH; |
||||
|
||||
#endif /* UNALIGNED_OK */ |
||||
|
||||
if (len > best_len) { |
||||
s->match_start = cur_match; |
||||
best_len = len; |
||||
if (len >= nice_match) break; |
||||
#ifdef UNALIGNED_OK |
||||
scan_end = *(ushf*)(scan+best_len-1); |
||||
#else |
||||
scan_end1 = scan[best_len-1]; |
||||
scan_end = scan[best_len]; |
||||
#endif |
||||
} |
||||
} while ((cur_match = prev[cur_match & wmask]) > limit |
||||
&& --chain_length != 0); |
||||
|
||||
if ((uInt)best_len <= s->lookahead) return best_len; |
||||
return s->lookahead; |
||||
} |
||||
|
||||
#endif /* ASMV */ |
||||
@ -0,0 +1 @@ |
||||
c:\masm611\bin\ml /coff /Zi /c /Flgvmat32.lst gvmat32.asm |
||||
@ -0,0 +1,781 @@ |
||||
# Microsoft Developer Studio Generated NMAKE File, Format Version 4.20
|
||||
# ** DO NOT EDIT **
|
||||
|
||||
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
|
||||
|
||||
!IF "$(CFG)" == "" |
||||
CFG=zlibvc - Win32 Debug
|
||||
!MESSAGE No configuration specified. Defaulting to zlibvc - Win32 Debug. |
||||
!ENDIF
|
||||
|
||||
!IF "$(CFG)" != "zlibvc - Win32 Release" && "$(CFG)" != "zlibvc - Win32 Debug" |
||||
!MESSAGE Invalid configuration "$(CFG)" specified. |
||||
!MESSAGE You can specify a configuration when running NMAKE on this makefile |
||||
!MESSAGE by defining the macro CFG on the command line. For example: |
||||
!MESSAGE
|
||||
!MESSAGE NMAKE /f "zlibvc.mak" CFG="zlibvc - Win32 Debug"
|
||||
!MESSAGE
|
||||
!MESSAGE Possible choices for configuration are: |
||||
!MESSAGE
|
||||
!MESSAGE "zlibvc - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library") |
||||
!MESSAGE "zlibvc - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library") |
||||
!MESSAGE
|
||||
!ERROR An invalid configuration is specified. |
||||
!ENDIF
|
||||
|
||||
!IF "$(OS)" == "Windows_NT" |
||||
NULL=
|
||||
!ELSE
|
||||
NULL=nul
|
||||
!ENDIF
|
||||
################################################################################
|
||||
# Begin Project
|
||||
# PROP Target_Last_Scanned "zlibvc - Win32 Debug"
|
||||
CPP=cl.exe
|
||||
RSC=rc.exe
|
||||
MTL=mktyplib.exe
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 0
|
||||
# PROP BASE Output_Dir "Release"
|
||||
# PROP BASE Intermediate_Dir "Release"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 0
|
||||
# PROP Output_Dir "Release"
|
||||
# PROP Intermediate_Dir "Release"
|
||||
# PROP Target_Dir ""
|
||||
OUTDIR=.\Release
|
||||
INTDIR=.\Release
|
||||
|
||||
ALL : "$(OUTDIR)\zlib.dll" "$(OUTDIR)\zlibvc.bsc" |
||||
|
||||
CLEAN : |
||||
-@erase "$(INTDIR)\adler32.obj"
|
||||
-@erase "$(INTDIR)\adler32.sbr"
|
||||
-@erase "$(INTDIR)\compress.obj"
|
||||
-@erase "$(INTDIR)\compress.sbr"
|
||||
-@erase "$(INTDIR)\crc32.obj"
|
||||
-@erase "$(INTDIR)\crc32.sbr"
|
||||
-@erase "$(INTDIR)\deflate.obj"
|
||||
-@erase "$(INTDIR)\deflate.sbr"
|
||||
-@erase "$(INTDIR)\gvmat32c.obj"
|
||||
-@erase "$(INTDIR)\gvmat32c.sbr"
|
||||
-@erase "$(INTDIR)\gzio.obj"
|
||||
-@erase "$(INTDIR)\gzio.sbr"
|
||||
-@erase "$(INTDIR)\infblock.obj"
|
||||
-@erase "$(INTDIR)\infblock.sbr"
|
||||
-@erase "$(INTDIR)\infcodes.obj"
|
||||
-@erase "$(INTDIR)\infcodes.sbr"
|
||||
-@erase "$(INTDIR)\inffast.obj"
|
||||
-@erase "$(INTDIR)\inffast.sbr"
|
||||
-@erase "$(INTDIR)\inflate.obj"
|
||||
-@erase "$(INTDIR)\inflate.sbr"
|
||||
-@erase "$(INTDIR)\inftrees.obj"
|
||||
-@erase "$(INTDIR)\inftrees.sbr"
|
||||
-@erase "$(INTDIR)\infutil.obj"
|
||||
-@erase "$(INTDIR)\infutil.sbr"
|
||||
-@erase "$(INTDIR)\trees.obj"
|
||||
-@erase "$(INTDIR)\trees.sbr"
|
||||
-@erase "$(INTDIR)\uncompr.obj"
|
||||
-@erase "$(INTDIR)\uncompr.sbr"
|
||||
-@erase "$(INTDIR)\zlib.res"
|
||||
-@erase "$(INTDIR)\zutil.obj"
|
||||
-@erase "$(INTDIR)\zutil.sbr"
|
||||
-@erase "$(OUTDIR)\zlib.dll"
|
||||
-@erase "$(OUTDIR)\zlib.exp"
|
||||
-@erase "$(OUTDIR)\zlib.lib"
|
||||
-@erase "$(OUTDIR)\zlib.map"
|
||||
-@erase "$(OUTDIR)\zlibvc.bsc"
|
||||
|
||||
"$(OUTDIR)" : |
||||
if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
|
||||
|
||||
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
|
||||
# ADD CPP /nologo /MT /W3 /GX /O2 /D "NDEBUG" /D fdopen=_fdopen /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "ASMV" /FR /YX /c
|
||||
CPP_PROJ=/nologo /MT /W3 /GX /O2 /D "NDEBUG" /D fdopen=_fdopen /D "WIN32" /D\
|
||||
"_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /D "ASMV"\
|
||||
/FR"$(INTDIR)/" /Fp"$(INTDIR)/zlibvc.pch" /YX /Fo"$(INTDIR)/" /c
|
||||
CPP_OBJS=.\Release/
|
||||
CPP_SBRS=.\Release/
|
||||
# ADD BASE MTL /nologo /D "NDEBUG" /win32
|
||||
# ADD MTL /nologo /D "NDEBUG" /win32
|
||||
MTL_PROJ=/nologo /D "NDEBUG" /win32
|
||||
# ADD BASE RSC /l 0x40c /d "NDEBUG"
|
||||
# ADD RSC /l 0x40c /d "NDEBUG"
|
||||
RSC_PROJ=/l 0x40c /fo"$(INTDIR)/zlib.res" /d "NDEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
BSC32_FLAGS=/nologo /o"$(OUTDIR)/zlibvc.bsc"
|
||||
BSC32_SBRS= \
|
||||
"$(INTDIR)\adler32.sbr" \
|
||||
"$(INTDIR)\compress.sbr" \
|
||||
"$(INTDIR)\crc32.sbr" \
|
||||
"$(INTDIR)\deflate.sbr" \
|
||||
"$(INTDIR)\gvmat32c.sbr" \
|
||||
"$(INTDIR)\gzio.sbr" \
|
||||
"$(INTDIR)\infblock.sbr" \
|
||||
"$(INTDIR)\infcodes.sbr" \
|
||||
"$(INTDIR)\inffast.sbr" \
|
||||
"$(INTDIR)\inflate.sbr" \
|
||||
"$(INTDIR)\inftrees.sbr" \
|
||||
"$(INTDIR)\infutil.sbr" \
|
||||
"$(INTDIR)\trees.sbr" \
|
||||
"$(INTDIR)\uncompr.sbr" \
|
||||
"$(INTDIR)\zutil.sbr"
|
||||
|
||||
"$(OUTDIR)\zlibvc.bsc" : "$(OUTDIR)" $(BSC32_SBRS) |
||||
$(BSC32) @<<
|
||||
$(BSC32_FLAGS) $(BSC32_SBRS)
|
||||
<< |
||||
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386
|
||||
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo /subsystem:windows /dll /map /machine:I386 /nodefaultlib /out:"Release/zlib.dll"
|
||||
LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
|
||||
advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib crtdll.lib /nologo\
|
||||
/subsystem:windows /dll /incremental:no /pdb:"$(OUTDIR)/zlib.pdb"\
|
||||
/map:"$(INTDIR)/zlib.map" /machine:I386 /nodefaultlib /def:".\zlib.def"\
|
||||
/out:"$(OUTDIR)/zlib.dll" /implib:"$(OUTDIR)/zlib.lib"
|
||||
DEF_FILE= \
|
||||
".\zlib.def"
|
||||
LINK32_OBJS= \
|
||||
"$(INTDIR)\adler32.obj" \
|
||||
"$(INTDIR)\compress.obj" \
|
||||
"$(INTDIR)\crc32.obj" \
|
||||
"$(INTDIR)\deflate.obj" \
|
||||
"$(INTDIR)\gvmat32c.obj" \
|
||||
"$(INTDIR)\gzio.obj" \
|
||||
"$(INTDIR)\infblock.obj" \
|
||||
"$(INTDIR)\infcodes.obj" \
|
||||
"$(INTDIR)\inffast.obj" \
|
||||
"$(INTDIR)\inflate.obj" \
|
||||
"$(INTDIR)\inftrees.obj" \
|
||||
"$(INTDIR)\infutil.obj" \
|
||||
"$(INTDIR)\trees.obj" \
|
||||
"$(INTDIR)\uncompr.obj" \
|
||||
"$(INTDIR)\zlib.res" \
|
||||
"$(INTDIR)\zutil.obj" \
|
||||
".\GVMAT32.obj"
|
||||
|
||||
"$(OUTDIR)\zlib.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) |
||||
$(LINK32) @<<
|
||||
$(LINK32_FLAGS) $(LINK32_OBJS)
|
||||
<< |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
# PROP BASE Use_MFC 0
|
||||
# PROP BASE Use_Debug_Libraries 1
|
||||
# PROP BASE Output_Dir "Debug"
|
||||
# PROP BASE Intermediate_Dir "Debug"
|
||||
# PROP BASE Target_Dir ""
|
||||
# PROP Use_MFC 0
|
||||
# PROP Use_Debug_Libraries 1
|
||||
# PROP Output_Dir "Debug"
|
||||
# PROP Intermediate_Dir "Debug"
|
||||
# PROP Target_Dir ""
|
||||
OUTDIR=.\Debug
|
||||
INTDIR=.\Debug
|
||||
|
||||
ALL : "$(OUTDIR)\zlib.dll" |
||||
|
||||
CLEAN : |
||||
-@erase "$(INTDIR)\adler32.obj"
|
||||
-@erase "$(INTDIR)\compress.obj"
|
||||
-@erase "$(INTDIR)\crc32.obj"
|
||||
-@erase "$(INTDIR)\deflate.obj"
|
||||
-@erase "$(INTDIR)\gvmat32c.obj"
|
||||
-@erase "$(INTDIR)\gzio.obj"
|
||||
-@erase "$(INTDIR)\infblock.obj"
|
||||
-@erase "$(INTDIR)\infcodes.obj"
|
||||
-@erase "$(INTDIR)\inffast.obj"
|
||||
-@erase "$(INTDIR)\inflate.obj"
|
||||
-@erase "$(INTDIR)\inftrees.obj"
|
||||
-@erase "$(INTDIR)\infutil.obj"
|
||||
-@erase "$(INTDIR)\trees.obj"
|
||||
-@erase "$(INTDIR)\uncompr.obj"
|
||||
-@erase "$(INTDIR)\vc40.idb"
|
||||
-@erase "$(INTDIR)\vc40.pdb"
|
||||
-@erase "$(INTDIR)\zlib.res"
|
||||
-@erase "$(INTDIR)\zutil.obj"
|
||||
-@erase "$(OUTDIR)\zlib.dll"
|
||||
-@erase "$(OUTDIR)\zlib.exp"
|
||||
-@erase "$(OUTDIR)\zlib.ilk"
|
||||
-@erase "$(OUTDIR)\zlib.lib"
|
||||
-@erase "$(OUTDIR)\zlib.pdb"
|
||||
|
||||
"$(OUTDIR)" : |
||||
if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)"
|
||||
|
||||
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
|
||||
# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS" /D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL" /YX /c
|
||||
CPP_PROJ=/nologo /MTd /W3 /Gm /GX /Zi /Od /D "_DEBUG" /D "WIN32" /D "_WINDOWS"\
|
||||
/D "_WINDLL" /D "_WIN32" /D "BUILD_ZLIBDLL" /D "ZLIB_DLL"\
|
||||
/Fp"$(INTDIR)/zlibvc.pch" /YX /Fo"$(INTDIR)/" /Fd"$(INTDIR)/" /c
|
||||
CPP_OBJS=.\Debug/
|
||||
CPP_SBRS=.\.
|
||||
# ADD BASE MTL /nologo /D "_DEBUG" /win32
|
||||
# ADD MTL /nologo /D "_DEBUG" /win32
|
||||
MTL_PROJ=/nologo /D "_DEBUG" /win32
|
||||
# ADD BASE RSC /l 0x40c /d "_DEBUG"
|
||||
# ADD RSC /l 0x40c /d "_DEBUG"
|
||||
RSC_PROJ=/l 0x40c /fo"$(INTDIR)/zlib.res" /d "_DEBUG"
|
||||
BSC32=bscmake.exe
|
||||
# ADD BASE BSC32 /nologo
|
||||
# ADD BSC32 /nologo
|
||||
BSC32_FLAGS=/nologo /o"$(OUTDIR)/zlibvc.bsc"
|
||||
BSC32_SBRS= \
|
||||
|
||||
LINK32=link.exe
|
||||
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386
|
||||
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo /subsystem:windows /dll /debug /machine:I386 /out:"Debug/zlib.dll"
|
||||
LINK32_FLAGS=kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib\
|
||||
advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib /nologo\
|
||||
/subsystem:windows /dll /incremental:yes /pdb:"$(OUTDIR)/zlib.pdb" /debug\
|
||||
/machine:I386 /def:".\zlib.def" /out:"$(OUTDIR)/zlib.dll"\
|
||||
/implib:"$(OUTDIR)/zlib.lib"
|
||||
DEF_FILE= \
|
||||
".\zlib.def"
|
||||
LINK32_OBJS= \
|
||||
"$(INTDIR)\adler32.obj" \
|
||||
"$(INTDIR)\compress.obj" \
|
||||
"$(INTDIR)\crc32.obj" \
|
||||
"$(INTDIR)\deflate.obj" \
|
||||
"$(INTDIR)\gvmat32c.obj" \
|
||||
"$(INTDIR)\gzio.obj" \
|
||||
"$(INTDIR)\infblock.obj" \
|
||||
"$(INTDIR)\infcodes.obj" \
|
||||
"$(INTDIR)\inffast.obj" \
|
||||
"$(INTDIR)\inflate.obj" \
|
||||
"$(INTDIR)\inftrees.obj" \
|
||||
"$(INTDIR)\infutil.obj" \
|
||||
"$(INTDIR)\trees.obj" \
|
||||
"$(INTDIR)\uncompr.obj" \
|
||||
"$(INTDIR)\zlib.res" \
|
||||
"$(INTDIR)\zutil.obj" \
|
||||
".\GVMAT32.obj"
|
||||
|
||||
"$(OUTDIR)\zlib.dll" : "$(OUTDIR)" $(DEF_FILE) $(LINK32_OBJS) |
||||
$(LINK32) @<<
|
||||
$(LINK32_FLAGS) $(LINK32_OBJS)
|
||||
<< |
||||
|
||||
!ENDIF
|
||||
|
||||
.c{$(CPP_OBJS)}.obj: |
||||
$(CPP) $(CPP_PROJ) $<
|
||||
|
||||
.cpp{$(CPP_OBJS)}.obj: |
||||
$(CPP) $(CPP_PROJ) $<
|
||||
|
||||
.cxx{$(CPP_OBJS)}.obj: |
||||
$(CPP) $(CPP_PROJ) $<
|
||||
|
||||
.c{$(CPP_SBRS)}.sbr: |
||||
$(CPP) $(CPP_PROJ) $<
|
||||
|
||||
.cpp{$(CPP_SBRS)}.sbr: |
||||
$(CPP) $(CPP_PROJ) $<
|
||||
|
||||
.cxx{$(CPP_SBRS)}.sbr: |
||||
$(CPP) $(CPP_PROJ) $<
|
||||
|
||||
################################################################################
|
||||
# Begin Target
|
||||
|
||||
# Name "zlibvc - Win32 Release"
|
||||
# Name "zlibvc - Win32 Debug"
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ENDIF
|
||||
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\adler32.c
|
||||
DEP_CPP_ADLER=\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
|
||||
"$(INTDIR)\adler32.obj" : $(SOURCE) $(DEP_CPP_ADLER) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\adler32.sbr" : $(SOURCE) $(DEP_CPP_ADLER) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
|
||||
"$(INTDIR)\adler32.obj" : $(SOURCE) $(DEP_CPP_ADLER) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\compress.c
|
||||
DEP_CPP_COMPR=\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
|
||||
"$(INTDIR)\compress.obj" : $(SOURCE) $(DEP_CPP_COMPR) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\compress.sbr" : $(SOURCE) $(DEP_CPP_COMPR) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
|
||||
"$(INTDIR)\compress.obj" : $(SOURCE) $(DEP_CPP_COMPR) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\crc32.c
|
||||
DEP_CPP_CRC32=\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
|
||||
"$(INTDIR)\crc32.obj" : $(SOURCE) $(DEP_CPP_CRC32) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\crc32.sbr" : $(SOURCE) $(DEP_CPP_CRC32) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
|
||||
"$(INTDIR)\crc32.obj" : $(SOURCE) $(DEP_CPP_CRC32) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\deflate.c
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
DEP_CPP_DEFLA=\
|
||||
".\deflate.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
"$(INTDIR)\deflate.obj" : $(SOURCE) $(DEP_CPP_DEFLA) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\deflate.sbr" : $(SOURCE) $(DEP_CPP_DEFLA) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
DEP_CPP_DEFLA=\
|
||||
".\deflate.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
NODEP_CPP_DEFLA=\
|
||||
".\local"\
|
||||
|
||||
|
||||
"$(INTDIR)\deflate.obj" : $(SOURCE) $(DEP_CPP_DEFLA) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\gzio.c
|
||||
DEP_CPP_GZIO_=\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
|
||||
"$(INTDIR)\gzio.obj" : $(SOURCE) $(DEP_CPP_GZIO_) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\gzio.sbr" : $(SOURCE) $(DEP_CPP_GZIO_) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
|
||||
"$(INTDIR)\gzio.obj" : $(SOURCE) $(DEP_CPP_GZIO_) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\infblock.c
|
||||
DEP_CPP_INFBL=\
|
||||
".\infblock.h"\
|
||||
".\infcodes.h"\
|
||||
".\inftrees.h"\
|
||||
".\infutil.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
|
||||
"$(INTDIR)\infblock.obj" : $(SOURCE) $(DEP_CPP_INFBL) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\infblock.sbr" : $(SOURCE) $(DEP_CPP_INFBL) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
|
||||
"$(INTDIR)\infblock.obj" : $(SOURCE) $(DEP_CPP_INFBL) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\infcodes.c
|
||||
DEP_CPP_INFCO=\
|
||||
".\infblock.h"\
|
||||
".\infcodes.h"\
|
||||
".\inffast.h"\
|
||||
".\inftrees.h"\
|
||||
".\infutil.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
|
||||
"$(INTDIR)\infcodes.obj" : $(SOURCE) $(DEP_CPP_INFCO) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\infcodes.sbr" : $(SOURCE) $(DEP_CPP_INFCO) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
|
||||
"$(INTDIR)\infcodes.obj" : $(SOURCE) $(DEP_CPP_INFCO) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\inffast.c
|
||||
DEP_CPP_INFFA=\
|
||||
".\infblock.h"\
|
||||
".\infcodes.h"\
|
||||
".\inffast.h"\
|
||||
".\inftrees.h"\
|
||||
".\infutil.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
|
||||
"$(INTDIR)\inffast.obj" : $(SOURCE) $(DEP_CPP_INFFA) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\inffast.sbr" : $(SOURCE) $(DEP_CPP_INFFA) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
|
||||
"$(INTDIR)\inffast.obj" : $(SOURCE) $(DEP_CPP_INFFA) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\inflate.c
|
||||
DEP_CPP_INFLA=\
|
||||
".\infblock.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
|
||||
"$(INTDIR)\inflate.obj" : $(SOURCE) $(DEP_CPP_INFLA) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\inflate.sbr" : $(SOURCE) $(DEP_CPP_INFLA) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
|
||||
"$(INTDIR)\inflate.obj" : $(SOURCE) $(DEP_CPP_INFLA) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\inftrees.c
|
||||
DEP_CPP_INFTR=\
|
||||
".\inftrees.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
|
||||
"$(INTDIR)\inftrees.obj" : $(SOURCE) $(DEP_CPP_INFTR) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\inftrees.sbr" : $(SOURCE) $(DEP_CPP_INFTR) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
|
||||
"$(INTDIR)\inftrees.obj" : $(SOURCE) $(DEP_CPP_INFTR) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\infutil.c
|
||||
DEP_CPP_INFUT=\
|
||||
".\infblock.h"\
|
||||
".\infcodes.h"\
|
||||
".\inftrees.h"\
|
||||
".\infutil.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
|
||||
"$(INTDIR)\infutil.obj" : $(SOURCE) $(DEP_CPP_INFUT) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\infutil.sbr" : $(SOURCE) $(DEP_CPP_INFUT) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
|
||||
"$(INTDIR)\infutil.obj" : $(SOURCE) $(DEP_CPP_INFUT) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\trees.c
|
||||
DEP_CPP_TREES=\
|
||||
".\deflate.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
|
||||
"$(INTDIR)\trees.obj" : $(SOURCE) $(DEP_CPP_TREES) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\trees.sbr" : $(SOURCE) $(DEP_CPP_TREES) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
|
||||
"$(INTDIR)\trees.obj" : $(SOURCE) $(DEP_CPP_TREES) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\uncompr.c
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
DEP_CPP_UNCOM=\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
|
||||
|
||||
"$(INTDIR)\uncompr.obj" : $(SOURCE) $(DEP_CPP_UNCOM) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\uncompr.sbr" : $(SOURCE) $(DEP_CPP_UNCOM) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
DEP_CPP_UNCOM=\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
|
||||
NODEP_CPP_UNCOM=\
|
||||
".\uncompress"\
|
||||
|
||||
|
||||
"$(INTDIR)\uncompr.obj" : $(SOURCE) $(DEP_CPP_UNCOM) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\zutil.c
|
||||
DEP_CPP_ZUTIL=\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
|
||||
"$(INTDIR)\zutil.obj" : $(SOURCE) $(DEP_CPP_ZUTIL) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\zutil.sbr" : $(SOURCE) $(DEP_CPP_ZUTIL) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
|
||||
"$(INTDIR)\zutil.obj" : $(SOURCE) $(DEP_CPP_ZUTIL) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\zlib.rc
|
||||
|
||||
"$(INTDIR)\zlib.res" : $(SOURCE) "$(INTDIR)" |
||||
$(RSC) $(RSC_PROJ) $(SOURCE)
|
||||
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\zlib.def
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\GVMAT32.obj
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
################################################################################
|
||||
# Begin Source File
|
||||
|
||||
SOURCE=.\gvmat32c.c
|
||||
|
||||
!IF "$(CFG)" == "zlibvc - Win32 Release" |
||||
|
||||
DEP_CPP_GVMAT=\
|
||||
".\deflate.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
"$(INTDIR)\gvmat32c.obj" : $(SOURCE) $(DEP_CPP_GVMAT) "$(INTDIR)" |
||||
|
||||
"$(INTDIR)\gvmat32c.sbr" : $(SOURCE) $(DEP_CPP_GVMAT) "$(INTDIR)" |
||||
|
||||
|
||||
!ELSEIF "$(CFG)" == "zlibvc - Win32 Debug" |
||||
|
||||
DEP_CPP_GVMAT=\
|
||||
".\deflate.h"\
|
||||
".\zconf.h"\
|
||||
".\zlib.h"\
|
||||
".\zutil.h"\
|
||||
|
||||
|
||||
"$(INTDIR)\gvmat32c.obj" : $(SOURCE) $(DEP_CPP_GVMAT) "$(INTDIR)" |
||||
|
||||
|
||||
!ENDIF
|
||||
|
||||
# End Source File
|
||||
# End Target
|
||||
# End Project
|
||||
################################################################################
|
||||
@ -0,0 +1,24 @@ |
||||
|
||||
#include "zfstream.h" |
||||
|
||||
int main() { |
||||
|
||||
// Construct a stream object with this filebuffer. Anything sent
|
||||
// to this stream will go to standard out.
|
||||
gzofstream os( 1, ios::out ); |
||||
|
||||
// This text is getting compressed and sent to stdout.
|
||||
// To prove this, run 'test | zcat'.
|
||||
os << "Hello, Mommy" << endl; |
||||
|
||||
os << setcompressionlevel( Z_NO_COMPRESSION ); |
||||
os << "hello, hello, hi, ho!" << endl; |
||||
|
||||
setcompressionlevel( os, Z_DEFAULT_COMPRESSION ) |
||||
<< "I'm compressing again" << endl; |
||||
|
||||
os.close(); |
||||
|
||||
return 0; |
||||
|
||||
} |
||||
@ -0,0 +1,329 @@ |
||||
|
||||
#include <memory.h> |
||||
#include "zfstream.h" |
||||
|
||||
gzfilebuf::gzfilebuf() : |
||||
file(NULL), |
||||
mode(0), |
||||
own_file_descriptor(0) |
||||
{ } |
||||
|
||||
gzfilebuf::~gzfilebuf() { |
||||
|
||||
sync(); |
||||
if ( own_file_descriptor ) |
||||
close(); |
||||
|
||||
} |
||||
|
||||
gzfilebuf *gzfilebuf::open( const char *name, |
||||
int io_mode ) { |
||||
|
||||
if ( is_open() ) |
||||
return NULL; |
||||
|
||||
char char_mode[10]; |
||||
char *p; |
||||
memset(char_mode,'\0',10); |
||||
p = char_mode; |
||||
|
||||
if ( io_mode & ios::in ) { |
||||
mode = ios::in; |
||||
*p++ = 'r'; |
||||
} else if ( io_mode & ios::app ) { |
||||
mode = ios::app; |
||||
*p++ = 'a'; |
||||
} else { |
||||
mode = ios::out; |
||||
*p++ = 'w'; |
||||
} |
||||
|
||||
if ( io_mode & ios::binary ) { |
||||
mode |= ios::binary; |
||||
*p++ = 'b'; |
||||
} |
||||
|
||||
// Hard code the compression level
|
||||
if ( io_mode & (ios::out|ios::app )) { |
||||
*p++ = '9'; |
||||
} |
||||
|
||||
if ( (file = gzopen(name, char_mode)) == NULL ) |
||||
return NULL; |
||||
|
||||
own_file_descriptor = 1; |
||||
|
||||
return this; |
||||
|
||||
} |
||||
|
||||
gzfilebuf *gzfilebuf::attach( int file_descriptor, |
||||
int io_mode ) { |
||||
|
||||
if ( is_open() ) |
||||
return NULL; |
||||
|
||||
char char_mode[10]; |
||||
char *p; |
||||
memset(char_mode,'\0',10); |
||||
p = char_mode; |
||||
|
||||
if ( io_mode & ios::in ) { |
||||
mode = ios::in; |
||||
*p++ = 'r'; |
||||
} else if ( io_mode & ios::app ) { |
||||
mode = ios::app; |
||||
*p++ = 'a'; |
||||
} else { |
||||
mode = ios::out; |
||||
*p++ = 'w'; |
||||
} |
||||
|
||||
if ( io_mode & ios::binary ) { |
||||
mode |= ios::binary; |
||||
*p++ = 'b'; |
||||
} |
||||
|
||||
// Hard code the compression level
|
||||
if ( io_mode & (ios::out|ios::app )) { |
||||
*p++ = '9'; |
||||
} |
||||
|
||||
if ( (file = gzdopen(file_descriptor, char_mode)) == NULL ) |
||||
return NULL; |
||||
|
||||
own_file_descriptor = 0; |
||||
|
||||
return this; |
||||
|
||||
} |
||||
|
||||
gzfilebuf *gzfilebuf::close() { |
||||
|
||||
if ( is_open() ) { |
||||
|
||||
sync(); |
||||
gzclose( file ); |
||||
file = NULL; |
||||
|
||||
} |
||||
|
||||
return this; |
||||
|
||||
} |
||||
|
||||
int gzfilebuf::setcompressionlevel( short comp_level ) { |
||||
|
||||
return gzsetparams(file, comp_level, -2); |
||||
|
||||
} |
||||
|
||||
int gzfilebuf::setcompressionstrategy( short comp_strategy ) { |
||||
|
||||
return gzsetparams(file, -2, comp_strategy); |
||||
|
||||
} |
||||
|
||||
|
||||
streampos gzfilebuf::seekoff( streamoff off, ios::seek_dir dir, int which ) { |
||||
|
||||
return streampos(EOF); |
||||
|
||||
} |
||||
|
||||
int gzfilebuf::underflow() { |
||||
|
||||
// If the file hasn't been opened for reading, error.
|
||||
if ( !is_open() || !(mode & ios::in) ) |
||||
return EOF; |
||||
|
||||
// if a buffer doesn't exists, allocate one.
|
||||
if ( !base() ) { |
||||
|
||||
if ( (allocate()) == EOF ) |
||||
return EOF; |
||||
setp(0,0); |
||||
|
||||
} else { |
||||
|
||||
if ( in_avail() ) |
||||
return (unsigned char) *gptr(); |
||||
|
||||
if ( out_waiting() ) { |
||||
if ( flushbuf() == EOF ) |
||||
return EOF; |
||||
} |
||||
|
||||
} |
||||
|
||||
// Attempt to fill the buffer.
|
||||
|
||||
int result = fillbuf(); |
||||
if ( result == EOF ) { |
||||
// disable get area
|
||||
setg(0,0,0); |
||||
return EOF; |
||||
} |
||||
|
||||
return (unsigned char) *gptr(); |
||||
|
||||
} |
||||
|
||||
int gzfilebuf::overflow( int c ) { |
||||
|
||||
if ( !is_open() || !(mode & ios::out) ) |
||||
return EOF; |
||||
|
||||
if ( !base() ) { |
||||
if ( allocate() == EOF ) |
||||
return EOF; |
||||
setg(0,0,0); |
||||
} else { |
||||
if (in_avail()) { |
||||
return EOF; |
||||
} |
||||
if (out_waiting()) { |
||||
if (flushbuf() == EOF) |
||||
return EOF; |
||||
} |
||||
} |
||||
|
||||
int bl = blen(); |
||||
setp( base(), base() + bl); |
||||
|
||||
if ( c != EOF ) { |
||||
|
||||
*pptr() = c; |
||||
pbump(1); |
||||
|
||||
} |
||||
|
||||
return 0; |
||||
|
||||
} |
||||
|
||||
int gzfilebuf::sync() { |
||||
|
||||
if ( !is_open() ) |
||||
return EOF; |
||||
|
||||
if ( out_waiting() ) |
||||
return flushbuf(); |
||||
|
||||
return 0; |
||||
|
||||
} |
||||
|
||||
int gzfilebuf::flushbuf() { |
||||
|
||||
int n; |
||||
char *q; |
||||
|
||||
q = pbase(); |
||||
n = pptr() - q; |
||||
|
||||
if ( gzwrite( file, q, n) < n ) |
||||
return EOF; |
||||
|
||||
setp(0,0); |
||||
|
||||
return 0; |
||||
|
||||
} |
||||
|
||||
int gzfilebuf::fillbuf() { |
||||
|
||||
int required; |
||||
char *p; |
||||
|
||||
p = base(); |
||||
|
||||
required = blen(); |
||||
|
||||
int t = gzread( file, p, required ); |
||||
|
||||
if ( t <= 0) return EOF; |
||||
|
||||
setg( base(), base(), base()+t); |
||||
|
||||
return t; |
||||
|
||||
} |
||||
|
||||
gzfilestream_common::gzfilestream_common() : |
||||
ios( gzfilestream_common::rdbuf() ) |
||||
{ } |
||||
|
||||
gzfilestream_common::~gzfilestream_common() |
||||
{ } |
||||
|
||||
void gzfilestream_common::attach( int fd, int io_mode ) { |
||||
|
||||
if ( !buffer.attach( fd, io_mode) ) |
||||
clear( ios::failbit | ios::badbit ); |
||||
else |
||||
clear(); |
||||
|
||||
} |
||||
|
||||
void gzfilestream_common::open( const char *name, int io_mode ) { |
||||
|
||||
if ( !buffer.open( name, io_mode ) ) |
||||
clear( ios::failbit | ios::badbit ); |
||||
else |
||||
clear(); |
||||
|
||||
} |
||||
|
||||
void gzfilestream_common::close() { |
||||
|
||||
if ( !buffer.close() ) |
||||
clear( ios::failbit | ios::badbit ); |
||||
|
||||
} |
||||
|
||||
gzfilebuf *gzfilestream_common::rdbuf() { |
||||
|
||||
return &buffer; |
||||
|
||||
} |
||||
|
||||
gzifstream::gzifstream() : |
||||
ios( gzfilestream_common::rdbuf() ) |
||||
{ |
||||
clear( ios::badbit ); |
||||
} |
||||
|
||||
gzifstream::gzifstream( const char *name, int io_mode ) : |
||||
ios( gzfilestream_common::rdbuf() ) |
||||
{ |
||||
gzfilestream_common::open( name, io_mode ); |
||||
} |
||||
|
||||
gzifstream::gzifstream( int fd, int io_mode ) : |
||||
ios( gzfilestream_common::rdbuf() ) |
||||
{ |
||||
gzfilestream_common::attach( fd, io_mode ); |
||||
} |
||||
|
||||
gzifstream::~gzifstream() { } |
||||
|
||||
gzofstream::gzofstream() : |
||||
ios( gzfilestream_common::rdbuf() ) |
||||
{ |
||||
clear( ios::badbit ); |
||||
} |
||||
|
||||
gzofstream::gzofstream( const char *name, int io_mode ) : |
||||
ios( gzfilestream_common::rdbuf() ) |
||||
{ |
||||
gzfilestream_common::open( name, io_mode ); |
||||
} |
||||
|
||||
gzofstream::gzofstream( int fd, int io_mode ) : |
||||
ios( gzfilestream_common::rdbuf() ) |
||||
{ |
||||
gzfilestream_common::attach( fd, io_mode ); |
||||
} |
||||
|
||||
gzofstream::~gzofstream() { } |
||||
@ -0,0 +1,142 @@ |
||||
|
||||
#ifndef _zfstream_h |
||||
#define _zfstream_h |
||||
|
||||
#include <fstream.h> |
||||
#include "zlib.h" |
||||
|
||||
class gzfilebuf : public streambuf { |
||||
|
||||
public: |
||||
|
||||
gzfilebuf( ); |
||||
virtual ~gzfilebuf(); |
||||
|
||||
gzfilebuf *open( const char *name, int io_mode ); |
||||
gzfilebuf *attach( int file_descriptor, int io_mode ); |
||||
gzfilebuf *close(); |
||||
|
||||
int setcompressionlevel( short comp_level ); |
||||
int setcompressionstrategy( short comp_strategy ); |
||||
|
||||
inline int is_open() const { return (file !=NULL); } |
||||
|
||||
virtual streampos seekoff( streamoff, ios::seek_dir, int ); |
||||
|
||||
virtual int sync(); |
||||
|
||||
protected: |
||||
|
||||
virtual int underflow(); |
||||
virtual int overflow( int = EOF ); |
||||
|
||||
private: |
||||
|
||||
gzFile file; |
||||
short mode; |
||||
short own_file_descriptor; |
||||
|
||||
int flushbuf(); |
||||
int fillbuf(); |
||||
|
||||
}; |
||||
|
||||
class gzfilestream_common : virtual public ios { |
||||
|
||||
friend class gzifstream; |
||||
friend class gzofstream; |
||||
friend gzofstream &setcompressionlevel( gzofstream &, int ); |
||||
friend gzofstream &setcompressionstrategy( gzofstream &, int ); |
||||
|
||||
public: |
||||
virtual ~gzfilestream_common(); |
||||
|
||||
void attach( int fd, int io_mode ); |
||||
void open( const char *name, int io_mode ); |
||||
void close(); |
||||
|
||||
protected: |
||||
gzfilestream_common(); |
||||
|
||||
private: |
||||
gzfilebuf *rdbuf(); |
||||
|
||||
gzfilebuf buffer; |
||||
|
||||
}; |
||||
|
||||
class gzifstream : public gzfilestream_common, public istream { |
||||
|
||||
public: |
||||
|
||||
gzifstream(); |
||||
gzifstream( const char *name, int io_mode = ios::in ); |
||||
gzifstream( int fd, int io_mode = ios::in ); |
||||
|
||||
virtual ~gzifstream(); |
||||
|
||||
}; |
||||
|
||||
class gzofstream : public gzfilestream_common, public ostream { |
||||
|
||||
public: |
||||
|
||||
gzofstream(); |
||||
gzofstream( const char *name, int io_mode = ios::out ); |
||||
gzofstream( int fd, int io_mode = ios::out ); |
||||
|
||||
virtual ~gzofstream(); |
||||
|
||||
}; |
||||
|
||||
template<class T> class gzomanip { |
||||
friend gzofstream &operator<<(gzofstream &, const gzomanip<T> &); |
||||
public: |
||||
gzomanip(gzofstream &(*f)(gzofstream &, T), T v) : func(f), val(v) { } |
||||
private: |
||||
gzofstream &(*func)(gzofstream &, T); |
||||
T val; |
||||
}; |
||||
|
||||
template<class T> gzofstream &operator<<(gzofstream &s, |
||||
const gzomanip<T> &m) { |
||||
return (*m.func)(s, m.val); |
||||
|
||||
} |
||||
|
||||
inline gzofstream &setcompressionlevel( gzofstream &s, int l ) { |
||||
(s.rdbuf())->setcompressionlevel(l); |
||||
return s; |
||||
} |
||||
|
||||
inline gzofstream &setcompressionstrategy( gzofstream &s, int l ) { |
||||
(s.rdbuf())->setcompressionstrategy(l); |
||||
return s; |
||||
} |
||||
|
||||
inline gzomanip<int> setcompressionlevel(int l) |
||||
{ |
||||
return gzomanip<int>(&setcompressionlevel,l); |
||||
} |
||||
|
||||
inline gzomanip<int> setcompressionstrategy(int l) |
||||
{ |
||||
return gzomanip<int>(&setcompressionstrategy,l); |
||||
} |
||||
|
||||
#endif |
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,307 @@ |
||||
/*
|
||||
* |
||||
* Copyright (c) 1997 |
||||
* Christian Michelsen Research AS |
||||
* Advanced Computing |
||||
* Fantoftvegen 38, 5036 BERGEN, Norway |
||||
* http://www.cmr.no
|
||||
* |
||||
* Permission to use, copy, modify, distribute and sell this software |
||||
* and its documentation for any purpose is hereby granted without fee, |
||||
* provided that the above copyright notice appear in all copies and |
||||
* that both that copyright notice and this permission notice appear |
||||
* in supporting documentation. Christian Michelsen Research AS makes no |
||||
* representations about the suitability of this software for any |
||||
* purpose. It is provided "as is" without express or implied warranty. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef ZSTREAM__H |
||||
#define ZSTREAM__H |
||||
|
||||
/*
|
||||
* zstream.h - C++ interface to the 'zlib' general purpose compression library |
||||
* $Id: zstream.h 1.1 1997-06-25 12:00:56+02 tyge Exp tyge $ |
||||
*/ |
||||
|
||||
#include <strstream.h> |
||||
#include <string.h> |
||||
#include <stdio.h> |
||||
#include "zlib.h" |
||||
|
||||
#if defined(_WIN32) |
||||
# include <fcntl.h> |
||||
# include <io.h> |
||||
# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY) |
||||
#else |
||||
# define SET_BINARY_MODE(file) |
||||
#endif |
||||
|
||||
class zstringlen { |
||||
public: |
||||
zstringlen(class izstream&); |
||||
zstringlen(class ozstream&, const char*); |
||||
size_t value() const { return val.word; } |
||||
private: |
||||
struct Val { unsigned char byte; size_t word; } val; |
||||
}; |
||||
|
||||
// ----------------------------- izstream -----------------------------
|
||||
|
||||
class izstream |
||||
{ |
||||
public: |
||||
izstream() : m_fp(0) {} |
||||
izstream(FILE* fp) : m_fp(0) { open(fp); } |
||||
izstream(const char* name) : m_fp(0) { open(name); } |
||||
~izstream() { close(); } |
||||
|
||||
/* Opens a gzip (.gz) file for reading.
|
||||
* open() can be used to read a file which is not in gzip format; |
||||
* in this case read() will directly read from the file without |
||||
* decompression. errno can be checked to distinguish two error |
||||
* cases (if errno is zero, the zlib error is Z_MEM_ERROR). |
||||
*/ |
||||
void open(const char* name) { |
||||
if (m_fp) close(); |
||||
m_fp = ::gzopen(name, "rb"); |
||||
} |
||||
|
||||
void open(FILE* fp) { |
||||
SET_BINARY_MODE(fp); |
||||
if (m_fp) close(); |
||||
m_fp = ::gzdopen(fileno(fp), "rb"); |
||||
} |
||||
|
||||
/* Flushes all pending input if necessary, closes the compressed file
|
||||
* and deallocates all the (de)compression state. The return value is |
||||
* the zlib error number (see function error() below). |
||||
*/ |
||||
int close() { |
||||
int r = ::gzclose(m_fp); |
||||
m_fp = 0; return r; |
||||
} |
||||
|
||||
/* Binary read the given number of bytes from the compressed file.
|
||||
*/ |
||||
int read(void* buf, size_t len) { |
||||
return ::gzread(m_fp, buf, len); |
||||
} |
||||
|
||||
/* Returns the error message for the last error which occurred on the
|
||||
* given compressed file. errnum is set to zlib error number. If an |
||||
* error occurred in the file system and not in the compression library, |
||||
* errnum is set to Z_ERRNO and the application may consult errno |
||||
* to get the exact error code. |
||||
*/ |
||||
const char* error(int* errnum) { |
||||
return ::gzerror(m_fp, errnum); |
||||
} |
||||
|
||||
gzFile fp() { return m_fp; } |
||||
|
||||
private: |
||||
gzFile m_fp; |
||||
}; |
||||
|
||||
/*
|
||||
* Binary read the given (array of) object(s) from the compressed file. |
||||
* If the input file was not in gzip format, read() copies the objects number |
||||
* of bytes into the buffer. |
||||
* returns the number of uncompressed bytes actually read |
||||
* (0 for end of file, -1 for error). |
||||
*/ |
||||
template <class T, class Items> |
||||
inline int read(izstream& zs, T* x, Items items) { |
||||
return ::gzread(zs.fp(), x, items*sizeof(T)); |
||||
} |
||||
|
||||
/*
|
||||
* Binary input with the '>' operator. |
||||
*/ |
||||
template <class T> |
||||
inline izstream& operator>(izstream& zs, T& x) { |
||||
::gzread(zs.fp(), &x, sizeof(T)); |
||||
return zs; |
||||
} |
||||
|
||||
|
||||
inline zstringlen::zstringlen(izstream& zs) { |
||||
zs > val.byte; |
||||
if (val.byte == 255) zs > val.word; |
||||
else val.word = val.byte; |
||||
} |
||||
|
||||
/*
|
||||
* Read length of string + the string with the '>' operator. |
||||
*/ |
||||
inline izstream& operator>(izstream& zs, char* x) { |
||||
zstringlen len(zs); |
||||
::gzread(zs.fp(), x, len.value()); |
||||
x[len.value()] = '\0'; |
||||
return zs; |
||||
} |
||||
|
||||
inline char* read_string(izstream& zs) { |
||||
zstringlen len(zs); |
||||
char* x = new char[len.value()+1]; |
||||
::gzread(zs.fp(), x, len.value()); |
||||
x[len.value()] = '\0'; |
||||
return x; |
||||
} |
||||
|
||||
// ----------------------------- ozstream -----------------------------
|
||||
|
||||
class ozstream |
||||
{ |
||||
public: |
||||
ozstream() : m_fp(0), m_os(0) { |
||||
} |
||||
ozstream(FILE* fp, int level = Z_DEFAULT_COMPRESSION) |
||||
: m_fp(0), m_os(0) { |
||||
open(fp, level); |
||||
} |
||||
ozstream(const char* name, int level = Z_DEFAULT_COMPRESSION) |
||||
: m_fp(0), m_os(0) { |
||||
open(name, level); |
||||
} |
||||
~ozstream() { |
||||
close(); |
||||
} |
||||
|
||||
/* Opens a gzip (.gz) file for writing.
|
||||
* The compression level parameter should be in 0..9 |
||||
* errno can be checked to distinguish two error cases |
||||
* (if errno is zero, the zlib error is Z_MEM_ERROR). |
||||
*/ |
||||
void open(const char* name, int level = Z_DEFAULT_COMPRESSION) { |
||||
char mode[4] = "wb\0"; |
||||
if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level; |
||||
if (m_fp) close(); |
||||
m_fp = ::gzopen(name, mode); |
||||
} |
||||
|
||||
/* open from a FILE pointer.
|
||||
*/ |
||||
void open(FILE* fp, int level = Z_DEFAULT_COMPRESSION) { |
||||
SET_BINARY_MODE(fp); |
||||
char mode[4] = "wb\0"; |
||||
if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level; |
||||
if (m_fp) close(); |
||||
m_fp = ::gzdopen(fileno(fp), mode); |
||||
} |
||||
|
||||
/* Flushes all pending output if necessary, closes the compressed file
|
||||
* and deallocates all the (de)compression state. The return value is |
||||
* the zlib error number (see function error() below). |
||||
*/ |
||||
int close() { |
||||
if (m_os) { |
||||
::gzwrite(m_fp, m_os->str(), m_os->pcount()); |
||||
delete[] m_os->str(); delete m_os; m_os = 0; |
||||
} |
||||
int r = ::gzclose(m_fp); m_fp = 0; return r; |
||||
} |
||||
|
||||
/* Binary write the given number of bytes into the compressed file.
|
||||
*/ |
||||
int write(const void* buf, size_t len) { |
||||
return ::gzwrite(m_fp, (voidp) buf, len); |
||||
} |
||||
|
||||
/* Flushes all pending output into the compressed file. The parameter
|
||||
* _flush is as in the deflate() function. The return value is the zlib |
||||
* error number (see function gzerror below). flush() returns Z_OK if |
||||
* the flush_ parameter is Z_FINISH and all output could be flushed. |
||||
* flush() should be called only when strictly necessary because it can |
||||
* degrade compression. |
||||
*/ |
||||
int flush(int _flush) { |
||||
os_flush(); |
||||
return ::gzflush(m_fp, _flush); |
||||
} |
||||
|
||||
/* Returns the error message for the last error which occurred on the
|
||||
* given compressed file. errnum is set to zlib error number. If an |
||||
* error occurred in the file system and not in the compression library, |
||||
* errnum is set to Z_ERRNO and the application may consult errno |
||||
* to get the exact error code. |
||||
*/ |
||||
const char* error(int* errnum) { |
||||
return ::gzerror(m_fp, errnum); |
||||
} |
||||
|
||||
gzFile fp() { return m_fp; } |
||||
|
||||
ostream& os() { |
||||
if (m_os == 0) m_os = new ostrstream; |
||||
return *m_os; |
||||
} |
||||
|
||||
void os_flush() { |
||||
if (m_os && m_os->pcount()>0) { |
||||
ostrstream* oss = new ostrstream; |
||||
oss->fill(m_os->fill()); |
||||
oss->flags(m_os->flags()); |
||||
oss->precision(m_os->precision()); |
||||
oss->width(m_os->width()); |
||||
::gzwrite(m_fp, m_os->str(), m_os->pcount()); |
||||
delete[] m_os->str(); delete m_os; m_os = oss; |
||||
} |
||||
} |
||||
|
||||
private: |
||||
gzFile m_fp; |
||||
ostrstream* m_os; |
||||
}; |
||||
|
||||
/*
|
||||
* Binary write the given (array of) object(s) into the compressed file. |
||||
* returns the number of uncompressed bytes actually written |
||||
* (0 in case of error). |
||||
*/ |
||||
template <class T, class Items> |
||||
inline int write(ozstream& zs, const T* x, Items items) { |
||||
return ::gzwrite(zs.fp(), (voidp) x, items*sizeof(T)); |
||||
} |
||||
|
||||
/*
|
||||
* Binary output with the '<' operator. |
||||
*/ |
||||
template <class T> |
||||
inline ozstream& operator<(ozstream& zs, const T& x) { |
||||
::gzwrite(zs.fp(), (voidp) &x, sizeof(T)); |
||||
return zs; |
||||
} |
||||
|
||||
inline zstringlen::zstringlen(ozstream& zs, const char* x) { |
||||
val.byte = 255; val.word = ::strlen(x); |
||||
if (val.word < 255) zs < (val.byte = val.word); |
||||
else zs < val; |
||||
} |
||||
|
||||
/*
|
||||
* Write length of string + the string with the '<' operator. |
||||
*/ |
||||
inline ozstream& operator<(ozstream& zs, const char* x) { |
||||
zstringlen len(zs, x); |
||||
::gzwrite(zs.fp(), (voidp) x, len.value()); |
||||
return zs; |
||||
} |
||||
|
||||
#ifdef _MSC_VER |
||||
inline ozstream& operator<(ozstream& zs, char* const& x) { |
||||
return zs < (const char*) x; |
||||
} |
||||
#endif |
||||
|
||||
/*
|
||||
* Ascii write with the << operator; |
||||
*/ |
||||
template <class T> |
||||
inline ostream& operator<<(ozstream& zs, const T& x) { |
||||
zs.os_flush(); |
||||
return zs.os() << x; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,25 @@ |
||||
#include "zstream.h" |
||||
#include <math.h> |
||||
#include <stdlib.h> |
||||
#include <iomanip.h> |
||||
|
||||
void main() { |
||||
char h[256] = "Hello"; |
||||
char* g = "Goodbye"; |
||||
ozstream out("temp.gz"); |
||||
out < "This works well" < h < g; |
||||
out.close(); |
||||
|
||||
izstream in("temp.gz"); // read it back
|
||||
char *x = read_string(in), *y = new char[256], z[256]; |
||||
in > y > z; |
||||
in.close(); |
||||
cout << x << endl << y << endl << z << endl; |
||||
|
||||
out.open("temp.gz"); // try ascii output; zcat temp.gz to see the results
|
||||
out << setw(50) << setfill('#') << setprecision(20) << x << endl << y << endl << z << endl; |
||||
out << z << endl << y << endl << x << endl; |
||||
out << 1.1234567890123456789 << endl; |
||||
|
||||
delete[] x; delete[] y; |
||||
} |
||||
@ -0,0 +1,14 @@ |
||||
CC=cc
|
||||
CFLAGS=-g
|
||||
|
||||
untgz: untgz.o ../../libz.a |
||||
$(CC) $(CFLAGS) -o untgz untgz.o -L../.. -lz
|
||||
|
||||
untgz.o: untgz.c ../../zlib.h |
||||
$(CC) $(CFLAGS) -c -I../.. untgz.c
|
||||
|
||||
../../libz.a: |
||||
cd ../..; make
|
||||
|
||||
clean: |
||||
rm -f untgz untgz.o *~
|
||||
@ -0,0 +1,63 @@ |
||||
# Makefile for zlib. Modified for mingw32 |
||||
# For conditions of distribution and use, see copyright notice in zlib.h |
||||
|
||||
# To compile, |
||||
# |
||||
# make -fmakefile.w32 |
||||
# |
||||
|
||||
CC=gcc |
||||
|
||||
# Generate dependencies (see end of the file) |
||||
|
||||
CPPFLAGS=-MMD |
||||
|
||||
#CFLAGS=-MMD -O |
||||
#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7 |
||||
#CFLAGS=-MMD -g -DDEBUG |
||||
CFLAGS=-O3 $(BUTT) -Wall -Wwrite-strings -Wpointer-arith -Wconversion \ |
||||
-Wstrict-prototypes -Wmissing-prototypes |
||||
|
||||
# If cp.exe is not found, replace with copy /Y . |
||||
CP=cp -f |
||||
|
||||
# The default value of RM is "rm -f." |
||||
# If "rm.exe" is not found, uncomment: |
||||
# RM=del |
||||
|
||||
LD=gcc |
||||
LDLIBS=-L. -lz |
||||
LDFLAGS=-s |
||||
|
||||
|
||||
INCL=zlib.h zconf.h |
||||
LIBS=libz.a |
||||
|
||||
AR=ar rcs |
||||
|
||||
OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \ |
||||
zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o \ |
||||
inffast.o |
||||
|
||||
TEST_OBJS = minigzip.o untgz.o |
||||
|
||||
all: minigzip.exe untgz.exe |
||||
|
||||
rebuild: clean all |
||||
|
||||
libz.a: $(OBJS) |
||||
$(AR) $@ $(OBJS) |
||||
|
||||
%.exe : %.o $(LIBS) |
||||
$(LD) $(LDFLAGS) -o $@ $< $(LDLIBS) |
||||
|
||||
.PHONY : clean |
||||
|
||||
clean: |
||||
$(RM) *.d *.o *.exe libz.a foo.gz |
||||
|
||||
DEPS := $(wildcard *.d) |
||||
ifneq ($(DEPS),) |
||||
include $(DEPS) |
||||
endif |
||||
|
||||
@ -0,0 +1,478 @@ |
||||
/*
|
||||
* untgz.c -- Display contents and/or extract file from |
||||
* a gzip'd TAR file |
||||
* written by "Pedro A. Aranda Guti\irrez" <paag@tid.es> |
||||
* adaptation to Unix by Jean-loup Gailly <jloup@gzip.org> |
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <time.h> |
||||
#include <utime.h> |
||||
#include <errno.h> |
||||
#include <fcntl.h> |
||||
#ifdef unix |
||||
# include <unistd.h> |
||||
#else |
||||
# include <direct.h> |
||||
# include <io.h> |
||||
#endif |
||||
|
||||
#include "zlib.h" |
||||
|
||||
/* Values used in typeflag field. */ |
||||
|
||||
#define REGTYPE '0' /* regular file */ |
||||
#define AREGTYPE '\0' /* regular file */ |
||||
#define LNKTYPE '1' /* link */ |
||||
#define SYMTYPE '2' /* reserved */ |
||||
#define CHRTYPE '3' /* character special */ |
||||
#define BLKTYPE '4' /* block special */ |
||||
#define DIRTYPE '5' /* directory */ |
||||
#define FIFOTYPE '6' /* FIFO special */ |
||||
#define CONTTYPE '7' /* reserved */ |
||||
|
||||
#define BLOCKSIZE 512 |
||||
|
||||
struct tar_header |
||||
{ /* byte offset */ |
||||
char name[100]; /* 0 */ |
||||
char mode[8]; /* 100 */ |
||||
char uid[8]; /* 108 */ |
||||
char gid[8]; /* 116 */ |
||||
char size[12]; /* 124 */ |
||||
char mtime[12]; /* 136 */ |
||||
char chksum[8]; /* 148 */ |
||||
char typeflag; /* 156 */ |
||||
char linkname[100]; /* 157 */ |
||||
char magic[6]; /* 257 */ |
||||
char version[2]; /* 263 */ |
||||
char uname[32]; /* 265 */ |
||||
char gname[32]; /* 297 */ |
||||
char devmajor[8]; /* 329 */ |
||||
char devminor[8]; /* 337 */ |
||||
char prefix[155]; /* 345 */ |
||||
/* 500 */ |
||||
}; |
||||
|
||||
union tar_buffer { |
||||
char buffer[BLOCKSIZE]; |
||||
struct tar_header header; |
||||
}; |
||||
|
||||
enum { TGZ_EXTRACT = 0, TGZ_LIST }; |
||||
|
||||
static char *TGZfname OF((const char *)); |
||||
void TGZnotfound OF((const char *)); |
||||
|
||||
int getoct OF((char *, int)); |
||||
char *strtime OF((time_t *)); |
||||
int ExprMatch OF((char *,char *)); |
||||
|
||||
int makedir OF((char *)); |
||||
int matchname OF((int,int,char **,char *)); |
||||
|
||||
void error OF((const char *)); |
||||
int tar OF((gzFile, int, int, int, char **)); |
||||
|
||||
void help OF((int)); |
||||
int main OF((int, char **)); |
||||
|
||||
char *prog; |
||||
|
||||
/* This will give a benign warning */ |
||||
|
||||
static char *TGZprefix[] = { "\0", ".tgz", ".tar.gz", NULL }; |
||||
|
||||
/* Return the real name of the TGZ archive */ |
||||
/* or NULL if it does not exist. */ |
||||
|
||||
static char *TGZfname OF((const char *fname)) |
||||
{ |
||||
static char buffer[1024]; |
||||
int origlen,i; |
||||
|
||||
strcpy(buffer,fname); |
||||
origlen = strlen(buffer); |
||||
|
||||
for (i=0; TGZprefix[i]; i++) |
||||
{ |
||||
strcpy(buffer+origlen,TGZprefix[i]); |
||||
if (access(buffer,F_OK) == 0) |
||||
return buffer; |
||||
} |
||||
return NULL; |
||||
} |
||||
|
||||
/* error message for the filename */ |
||||
|
||||
void TGZnotfound OF((const char *fname)) |
||||
{ |
||||
int i; |
||||
|
||||
fprintf(stderr,"%s : couldn't find ",prog); |
||||
for (i=0;TGZprefix[i];i++) |
||||
fprintf(stderr,(TGZprefix[i+1]) ? "%s%s, " : "or %s%s\n", |
||||
fname, |
||||
TGZprefix[i]); |
||||
exit(1); |
||||
} |
||||
|
||||
|
||||
/* help functions */ |
||||
|
||||
int getoct(char *p,int width) |
||||
{ |
||||
int result = 0; |
||||
char c; |
||||
|
||||
while (width --) |
||||
{ |
||||
c = *p++; |
||||
if (c == ' ') |
||||
continue; |
||||
if (c == 0) |
||||
break; |
||||
result = result * 8 + (c - '0'); |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
char *strtime (time_t *t) |
||||
{ |
||||
struct tm *local; |
||||
static char result[32]; |
||||
|
||||
local = localtime(t); |
||||
sprintf(result,"%2d/%02d/%4d %02d:%02d:%02d", |
||||
local->tm_mday, local->tm_mon+1, local->tm_year+1900, |
||||
local->tm_hour, local->tm_min, local->tm_sec); |
||||
return result; |
||||
} |
||||
|
||||
|
||||
/* regular expression matching */ |
||||
|
||||
#define ISSPECIAL(c) (((c) == '*') || ((c) == '/')) |
||||
|
||||
int ExprMatch(char *string,char *expr) |
||||
{ |
||||
while (1) |
||||
{ |
||||
if (ISSPECIAL(*expr)) |
||||
{ |
||||
if (*expr == '/') |
||||
{ |
||||
if (*string != '\\' && *string != '/') |
||||
return 0; |
||||
string ++; expr++; |
||||
} |
||||
else if (*expr == '*') |
||||
{ |
||||
if (*expr ++ == 0) |
||||
return 1; |
||||
while (*++string != *expr) |
||||
if (*string == 0) |
||||
return 0; |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
if (*string != *expr) |
||||
return 0; |
||||
if (*expr++ == 0) |
||||
return 1; |
||||
string++; |
||||
} |
||||
} |
||||
} |
||||
|
||||
/* recursive make directory */ |
||||
/* abort if you get an ENOENT errno somewhere in the middle */ |
||||
/* e.g. ignore error "mkdir on existing directory" */ |
||||
/* */ |
||||
/* return 1 if OK */ |
||||
/* 0 on error */ |
||||
|
||||
int makedir (char *newdir) |
||||
{ |
||||
char *buffer = strdup(newdir); |
||||
char *p; |
||||
int len = strlen(buffer); |
||||
|
||||
if (len <= 0) { |
||||
free(buffer); |
||||
return 0; |
||||
} |
||||
if (buffer[len-1] == '/') { |
||||
buffer[len-1] = '\0'; |
||||
} |
||||
if (mkdir(buffer, 0775) == 0) |
||||
{ |
||||
free(buffer); |
||||
return 1; |
||||
} |
||||
|
||||
p = buffer+1; |
||||
while (1) |
||||
{ |
||||
char hold; |
||||
|
||||
while(*p && *p != '\\' && *p != '/') |
||||
p++; |
||||
hold = *p; |
||||
*p = 0; |
||||
if ((mkdir(buffer, 0775) == -1) && (errno == ENOENT)) |
||||
{ |
||||
fprintf(stderr,"%s: couldn't create directory %s\n",prog,buffer); |
||||
free(buffer); |
||||
return 0; |
||||
} |
||||
if (hold == 0) |
||||
break; |
||||
*p++ = hold; |
||||
} |
||||
free(buffer); |
||||
return 1; |
||||
} |
||||
|
||||
int matchname (int arg,int argc,char **argv,char *fname) |
||||
{ |
||||
if (arg == argc) /* no arguments given (untgz tgzarchive) */ |
||||
return 1; |
||||
|
||||
while (arg < argc) |
||||
if (ExprMatch(fname,argv[arg++])) |
||||
return 1; |
||||
|
||||
return 0; /* ignore this for the moment being */ |
||||
} |
||||
|
||||
|
||||
/* Tar file list or extract */ |
||||
|
||||
int tar (gzFile in,int action,int arg,int argc,char **argv) |
||||
{ |
||||
union tar_buffer buffer; |
||||
int len; |
||||
int err; |
||||
int getheader = 1; |
||||
int remaining = 0; |
||||
FILE *outfile = NULL; |
||||
char fname[BLOCKSIZE]; |
||||
time_t tartime; |
||||
|
||||
if (action == TGZ_LIST) |
||||
printf(" day time size file\n" |
||||
" ---------- -------- --------- -------------------------------------\n"); |
||||
while (1) |
||||
{ |
||||
len = gzread(in, &buffer, BLOCKSIZE); |
||||
if (len < 0) |
||||
error (gzerror(in, &err)); |
||||
/*
|
||||
* if we met the end of the tar |
||||
* or the end-of-tar block, |
||||
* we are done |
||||
*/ |
||||
if ((len == 0) || (buffer.header.name[0]== 0)) |
||||
break; |
||||
|
||||
/*
|
||||
* Always expect complete blocks to process |
||||
* the tar information. |
||||
*/ |
||||
if (len != BLOCKSIZE) |
||||
error("gzread: incomplete block read"); |
||||
|
||||
/*
|
||||
* If we have to get a tar header |
||||
*/ |
||||
if (getheader == 1) |
||||
{ |
||||
tartime = (time_t)getoct(buffer.header.mtime,12); |
||||
strcpy(fname,buffer.header.name); |
||||
|
||||
switch (buffer.header.typeflag) |
||||
{ |
||||
case DIRTYPE: |
||||
if (action == TGZ_LIST) |
||||
printf(" %s <dir> %s\n",strtime(&tartime),fname); |
||||
if (action == TGZ_EXTRACT) |
||||
makedir(fname); |
||||
break; |
||||
case REGTYPE: |
||||
case AREGTYPE: |
||||
remaining = getoct(buffer.header.size,12); |
||||
if (action == TGZ_LIST) |
||||
printf(" %s %9d %s\n",strtime(&tartime),remaining,fname); |
||||
if (action == TGZ_EXTRACT) |
||||
{ |
||||
if ((remaining) && (matchname(arg,argc,argv,fname))) |
||||
{ |
||||
outfile = fopen(fname,"wb"); |
||||
if (outfile == NULL) { |
||||
/* try creating directory */ |
||||
char *p = strrchr(fname, '/'); |
||||
if (p != NULL) { |
||||
*p = '\0'; |
||||
makedir(fname); |
||||
*p = '/'; |
||||
outfile = fopen(fname,"wb"); |
||||
} |
||||
} |
||||
fprintf(stderr, |
||||
"%s %s\n", |
||||
(outfile) ? "Extracting" : "Couldn't create", |
||||
fname); |
||||
} |
||||
else |
||||
outfile = NULL; |
||||
} |
||||
/*
|
||||
* could have no contents |
||||
*/ |
||||
getheader = (remaining) ? 0 : 1; |
||||
break; |
||||
default: |
||||
if (action == TGZ_LIST) |
||||
printf(" %s <---> %s\n",strtime(&tartime),fname); |
||||
break; |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
unsigned int bytes = (remaining > BLOCKSIZE) ? BLOCKSIZE : remaining; |
||||
|
||||
if ((action == TGZ_EXTRACT) && (outfile != NULL)) |
||||
{ |
||||
if (fwrite(&buffer,sizeof(char),bytes,outfile) != bytes) |
||||
{ |
||||
fprintf(stderr,"%s : error writing %s skipping...\n",prog,fname); |
||||
fclose(outfile); |
||||
unlink(fname); |
||||
} |
||||
} |
||||
remaining -= bytes; |
||||
if (remaining == 0) |
||||
{ |
||||
getheader = 1; |
||||
if ((action == TGZ_EXTRACT) && (outfile != NULL)) |
||||
{ |
||||
struct utimbuf settime; |
||||
|
||||
settime.actime = settime.modtime = tartime; |
||||
|
||||
fclose(outfile); |
||||
outfile = NULL; |
||||
utime(fname,&settime); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
if (gzclose(in) != Z_OK) |
||||
error("failed gzclose"); |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
|
||||
/* =========================================================== */ |
||||
|
||||
void help(int exitval) |
||||
{ |
||||
fprintf(stderr, |
||||
"untgz v 0.1\n" |
||||
" an sample application of zlib 1.0.4\n\n" |
||||
"Usage : untgz TGZfile to extract all files\n" |
||||
" untgz TGZfile fname ... to extract selected files\n" |
||||
" untgz -l TGZfile to list archive contents\n" |
||||
" untgz -h to display this help\n\n"); |
||||
exit(exitval); |
||||
} |
||||
|
||||
void error(const char *msg) |
||||
{ |
||||
fprintf(stderr, "%s: %s\n", prog, msg); |
||||
exit(1); |
||||
} |
||||
|
||||
|
||||
/* ====================================================================== */ |
||||
|
||||
int _CRT_glob = 0; /* disable globbing of the arguments */ |
||||
|
||||
int main(int argc,char **argv) |
||||
{ |
||||
int action = TGZ_EXTRACT; |
||||
int arg = 1; |
||||
char *TGZfile; |
||||
gzFile *f; |
||||
|
||||
|
||||
prog = strrchr(argv[0],'\\'); |
||||
if (prog == NULL) |
||||
{ |
||||
prog = strrchr(argv[0],'/'); |
||||
if (prog == NULL) |
||||
{ |
||||
prog = strrchr(argv[0],':'); |
||||
if (prog == NULL) |
||||
prog = argv[0]; |
||||
else |
||||
prog++; |
||||
} |
||||
else |
||||
prog++; |
||||
} |
||||
else |
||||
prog++; |
||||
|
||||
if (argc == 1) |
||||
help(0); |
||||
|
||||
if (strcmp(argv[arg],"-l") == 0) |
||||
{ |
||||
action = TGZ_LIST; |
||||
if (argc == ++arg) |
||||
help(0); |
||||
} |
||||
else if (strcmp(argv[arg],"-h") == 0) |
||||
{ |
||||
help(0); |
||||
} |
||||
|
||||
if ((TGZfile = TGZfname(argv[arg])) == NULL) |
||||
TGZnotfound(argv[arg]);
|
||||
|
||||
++arg; |
||||
if ((action == TGZ_LIST) && (arg != argc)) |
||||
help(1); |
||||
|
||||
/*
|
||||
* Process the TGZ file |
||||
*/ |
||||
switch(action) |
||||
{ |
||||
case TGZ_LIST: |
||||
case TGZ_EXTRACT: |
||||
f = gzopen(TGZfile,"rb"); |
||||
if (f == NULL) |
||||
{ |
||||
fprintf(stderr,"%s: Couldn't gzopen %s\n", |
||||
prog, |
||||
TGZfile); |
||||
return 1; |
||||
} |
||||
exit(tar(f, action, arg, argc, argv)); |
||||
break; |
||||
|
||||
default: |
||||
error("Unknown option!"); |
||||
exit(1); |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
@ -0,0 +1,57 @@ |
||||
From: "Jon Caruana" <jon-net@usa.net> |
||||
To: "Jean-loup Gailly" <gzip@prep.ai.mit.edu> |
||||
Subject: Re: How to port zlib declares to vb? |
||||
Date: Mon, 28 Oct 1996 18:33:03 -0600 |
||||
|
||||
Got the answer! (I haven't had time to check this but it's what I got, and |
||||
looks correct): |
||||
|
||||
He has the following routines working: |
||||
compress |
||||
uncompress |
||||
gzopen |
||||
gzwrite |
||||
gzread |
||||
gzclose |
||||
|
||||
Declares follow: (Quoted from Carlos Rios <c_rios@sonda.cl>, in Vb4 form) |
||||
|
||||
#If Win16 Then 'Use Win16 calls. |
||||
Declare Function compress Lib "ZLIB.DLL" (ByVal compr As |
||||
String, comprLen As Any, ByVal buf As String, ByVal buflen |
||||
As Long) As Integer |
||||
Declare Function uncompress Lib "ZLIB.DLL" (ByVal uncompr |
||||
As String, uncomprLen As Any, ByVal compr As String, ByVal |
||||
lcompr As Long) As Integer |
||||
Declare Function gzopen Lib "ZLIB.DLL" (ByVal filePath As |
||||
String, ByVal mode As String) As Long |
||||
Declare Function gzread Lib "ZLIB.DLL" (ByVal file As |
||||
Long, ByVal uncompr As String, ByVal uncomprLen As Integer) |
||||
As Integer |
||||
Declare Function gzwrite Lib "ZLIB.DLL" (ByVal file As |
||||
Long, ByVal uncompr As String, ByVal uncomprLen As Integer) |
||||
As Integer |
||||
Declare Function gzclose Lib "ZLIB.DLL" (ByVal file As |
||||
Long) As Integer |
||||
#Else |
||||
Declare Function compress Lib "ZLIB32.DLL" |
||||
(ByVal compr As String, comprLen As Any, ByVal buf As |
||||
String, ByVal buflen As Long) As Integer |
||||
Declare Function uncompress Lib "ZLIB32.DLL" |
||||
(ByVal uncompr As String, uncomprLen As Any, ByVal compr As |
||||
String, ByVal lcompr As Long) As Long |
||||
Declare Function gzopen Lib "ZLIB32.DLL" |
||||
(ByVal file As String, ByVal mode As String) As Long |
||||
Declare Function gzread Lib "ZLIB32.DLL" |
||||
(ByVal file As Long, ByVal uncompr As String, ByVal |
||||
uncomprLen As Long) As Long |
||||
Declare Function gzwrite Lib "ZLIB32.DLL" |
||||
(ByVal file As Long, ByVal uncompr As String, ByVal |
||||
uncomprLen As Long) As Long |
||||
Declare Function gzclose Lib "ZLIB32.DLL" |
||||
(ByVal file As Long) As Long |
||||
#End If |
||||
|
||||
-Jon Caruana |
||||
jon-net@usa.net |
||||
Microsoft Sitebuilder Network Level 1 Member - HTML Writer's Guild Member |
||||
@ -0,0 +1,57 @@ |
||||
LIBRARY "zlib" |
||||
|
||||
DESCRIPTION '"""zlib data compression library"""' |
||||
|
||||
EXETYPE NT |
||||
|
||||
SUBSYSTEM WINDOWS |
||||
|
||||
STUB 'WINSTUB.EXE' |
||||
|
||||
VERSION 1.07 |
||||
|
||||
CODE EXECUTE READ |
||||
|
||||
DATA READ WRITE |
||||
|
||||
HEAPSIZE 1048576,4096 |
||||
|
||||
EXPORTS |
||||
adler32 @1 |
||||
compress @2 |
||||
crc32 @3 |
||||
deflate @4 |
||||
deflateCopy @5 |
||||
deflateEnd @6 |
||||
deflateInit2_ @7 |
||||
deflateInit_ @8 |
||||
deflateParams @9 |
||||
deflateReset @10 |
||||
deflateSetDictionary @11 |
||||
gzclose @12 |
||||
gzdopen @13 |
||||
gzerror @14 |
||||
gzflush @15 |
||||
gzopen @16 |
||||
gzread @17 |
||||
gzwrite @18 |
||||
inflate @19 |
||||
inflateEnd @20 |
||||
inflateInit2_ @21 |
||||
inflateInit_ @22 |
||||
inflateReset @23 |
||||
inflateSetDictionary @24 |
||||
inflateSync @25 |
||||
uncompress @26 |
||||
zlibVersion @27 |
||||
gzprintf @28 |
||||
gzputc @29 |
||||
gzgetc @30 |
||||
gzseek @31 |
||||
gzrewind @32 |
||||
gztell @33 |
||||
gzeof @34 |
||||
gzsetparams @35 |
||||
zError @36 |
||||
inflateSyncPoint @37 |
||||
get_crc_table @38 |
||||
@ -0,0 +1,88 @@ |
||||
# Makefile for zlib
|
||||
|
||||
!include <ntwin32.mak> |
||||
|
||||
CC=cl
|
||||
LD=link
|
||||
CFLAGS=-O -nologo
|
||||
LDFLAGS=
|
||||
O=.obj
|
||||
|
||||
# variables
|
||||
OBJ1 = adler32$(O) compress$(O) crc32$(O) gzio$(O) uncompr$(O) deflate$(O) \
|
||||
trees$(O)
|
||||
OBJ2 = zutil$(O) inflate$(O) infblock$(O) inftrees$(O) infcodes$(O) \
|
||||
infutil$(O) inffast$(O)
|
||||
|
||||
all: zlib.dll example.exe minigzip.exe |
||||
|
||||
adler32.obj: adler32.c zutil.h zlib.h zconf.h |
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
compress.obj: compress.c zlib.h zconf.h |
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
crc32.obj: crc32.c zutil.h zlib.h zconf.h |
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
deflate.obj: deflate.c deflate.h zutil.h zlib.h zconf.h |
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
gzio.obj: gzio.c zutil.h zlib.h zconf.h |
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
infblock.obj: infblock.c zutil.h zlib.h zconf.h infblock.h inftrees.h\
|
||||
infcodes.h infutil.h
|
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
infcodes.obj: infcodes.c zutil.h zlib.h zconf.h inftrees.h infutil.h\
|
||||
infcodes.h inffast.h
|
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
inflate.obj: inflate.c zutil.h zlib.h zconf.h infblock.h |
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
inftrees.obj: inftrees.c zutil.h zlib.h zconf.h inftrees.h |
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
infutil.obj: infutil.c zutil.h zlib.h zconf.h inftrees.h infutil.h |
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
inffast.obj: inffast.c zutil.h zlib.h zconf.h inftrees.h infutil.h inffast.h |
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
trees.obj: trees.c deflate.h zutil.h zlib.h zconf.h |
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
uncompr.obj: uncompr.c zlib.h zconf.h |
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
zutil.obj: zutil.c zutil.h zlib.h zconf.h |
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
example.obj: example.c zlib.h zconf.h |
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
minigzip.obj: minigzip.c zlib.h zconf.h |
||||
$(CC) -c $(cvarsdll) $(CFLAGS) $*.c
|
||||
|
||||
zlib.dll: $(OBJ1) $(OBJ2) zlib.dnt |
||||
link $(dlllflags) -out:$@ -def:zlib.dnt $(OBJ1) $(OBJ2) $(guilibsdll)
|
||||
|
||||
zlib.lib: zlib.dll |
||||
|
||||
example.exe: example.obj zlib.lib |
||||
$(LD) $(LDFLAGS) example.obj zlib.lib
|
||||
|
||||
minigzip.exe: minigzip.obj zlib.lib |
||||
$(LD) $(LDFLAGS) minigzip.obj zlib.lib
|
||||
|
||||
test: example.exe minigzip.exe |
||||
example
|
||||
echo hello world | minigzip | minigzip -d
|
||||
|
||||
clean: |
||||
del *.obj
|
||||
del *.exe
|
||||
del *.dll
|
||||
del *.lib
|
||||
@ -0,0 +1,44 @@ |
||||
LIBRARY zlib.dll |
||||
EXETYPE WINDOWS |
||||
CODE PRELOAD MOVEABLE DISCARDABLE |
||||
DATA PRELOAD MOVEABLE MULTIPLE |
||||
|
||||
EXPORTS |
||||
adler32 @1 |
||||
compress @2 |
||||
crc32 @3 |
||||
deflate @4 |
||||
deflateCopy @5 |
||||
deflateEnd @6 |
||||
deflateInit2_ @7 |
||||
deflateInit_ @8 |
||||
deflateParams @9 |
||||
deflateReset @10 |
||||
deflateSetDictionary @11 |
||||
gzclose @12 |
||||
gzdopen @13 |
||||
gzerror @14 |
||||
gzflush @15 |
||||
gzopen @16 |
||||
gzread @17 |
||||
gzwrite @18 |
||||
inflate @19 |
||||
inflateEnd @20 |
||||
inflateInit2_ @21 |
||||
inflateInit_ @22 |
||||
inflateReset @23 |
||||
inflateSetDictionary @24 |
||||
inflateSync @25 |
||||
uncompress @26 |
||||
zlibVersion @27 |
||||
gzprintf @28 |
||||
gzputc @29 |
||||
gzgetc @30 |
||||
gzseek @31 |
||||
gzrewind @32 |
||||
gztell @33 |
||||
gzeof @34 |
||||
gzsetparams @35 |
||||
zError @36 |
||||
inflateSyncPoint @37 |
||||
get_crc_table @38 |
||||
@ -0,0 +1,107 @@ |
||||
.TH ZLIB 3 "20 January 1998" |
||||
.SH NAME |
||||
zlib \- compression/decompression library |
||||
.SH SYNOPSIS |
||||
[see |
||||
.I zlib.h |
||||
for full descripton] |
||||
.SH DESCRIPTION |
||||
The |
||||
.I zlib |
||||
library is a general purpose data compression library. |
||||
The code is reentrant (thread safe). |
||||
It provides in-memory compression and decompression functions, |
||||
including integrity checks of the uncompressed data. |
||||
This version of the library supports only one compression method (deflation) |
||||
but other algorithms will be added later and will have the same stream interface. |
||||
.LP |
||||
Compression can be done in a single step if the buffers are large enough |
||||
(for example if an input file is mmap'ed), |
||||
or can be done by repeated calls of the compression function. |
||||
In the latter case, |
||||
the application must provide more input and/or consume the output |
||||
(providing more output space) before each call. |
||||
.LP |
||||
The library also supports reading and writing files in |
||||
.I gzip |
||||
(.gz) format |
||||
with an interface similar to that of stdio. |
||||
.LP |
||||
The library does not install any signal handler. The decoder checks |
||||
the consistency of the compressed data, so the library should never |
||||
crash even in case of corrupted input. |
||||
.LP |
||||
All functions of the compression library are documented in the file |
||||
.IR zlib.h. |
||||
The distribution source includes examples of use of the library |
||||
the files |
||||
.I example.c |
||||
and |
||||
.IR minigzip.c . |
||||
.LP |
||||
A Java implementation of |
||||
.IR zlib |
||||
is available in the Java Development Kit 1.1 |
||||
.IP |
||||
http://www.javasoft.com/products/JDK/1.1/docs/api/Package-java.util.zip.html |
||||
.LP |
||||
A Perl interface to |
||||
.IR zlib , |
||||
written by Paul Marquess (pmarquess@bfsec.bt.co.uk) |
||||
is available at CPAN (Comprehensive Perl Archive Network) sites, |
||||
such as: |
||||
.IP |
||||
ftp://ftp.cis.ufl.edu/pub/perl/CPAN/modules/by-module/Compress/Compress-Zlib* |
||||
.LP |
||||
A Python interface to |
||||
.IR zlib |
||||
written by A.M. Kuchling <amk@magnet.com> |
||||
is available from the Python Software Association sites, such as: |
||||
.IP |
||||
ftp://ftp.python.org/pub/python/contrib/Encoding/zlib*.tar.gz |
||||
.SH "SEE ALSO" |
||||
Questions about zlib should be sent to: |
||||
.IP |
||||
zlib@quest.jpl.nasa.gov |
||||
or, if this fails, to the author addresses given below. |
||||
The zlib home page is: |
||||
.IP |
||||
http://www.cdrom.com/infozip/zlib/ |
||||
.LP |
||||
The data format used by the zlib library is described by RFC |
||||
(Request for Comments) 1950 to 1952 in the files: |
||||
.IP |
||||
ftp://ds.internic.net/rfc/rfc1950.txt (zlib format) |
||||
.br |
||||
rfc1951.txt (deflate format) |
||||
.br |
||||
rfc1952.txt (gzip format) |
||||
.LP |
||||
These documents are also available in other formats from: |
||||
.IP |
||||
ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html |
||||
.SH AUTHORS |
||||
Version 1.0.7. |
||||
Copyright (C) 1995-1998 Jean-loup Gailly (jloup@gzip.org) |
||||
and Mark Adler (madler@alumni.caltech.edu). |
||||
.LP |
||||
This software is provided "as-is," |
||||
without any express or implied warranty. |
||||
In no event will the authors be held liable for any damages |
||||
arising from the use of this software. |
||||
See the distribution directory with respect to requirements |
||||
governing redistribution. |
||||
The deflate format used by |
||||
.I zlib |
||||
was defined by Phil Katz. |
||||
The deflate and |
||||
.I zlib |
||||
specifications were written by Peter Deutsch. |
||||
Thanks to all the people who reported problems and suggested various |
||||
improvements in |
||||
.IR zlib ; |
||||
who are too numerous to cite here. |
||||
.LP |
||||
UNIX manual page by R. P. C. Rodgers, |
||||
U.S. National Library of Medicine (rodgers@nlm.nih.gov). |
||||
.\" end of man page |
||||
@ -1,46 +0,0 @@ |
||||
LIBRARY "zlib" |
||||
|
||||
DESCRIPTION '"""zlib data compression library"""' |
||||
|
||||
EXETYPE NT |
||||
|
||||
SUBSYSTEM WINDOWS |
||||
|
||||
STUB 'WINSTUB.EXE' |
||||
|
||||
VERSION 1.05 |
||||
|
||||
CODE EXECUTE READ |
||||
|
||||
DATA READ WRITE |
||||
|
||||
HEAPSIZE 1048576,4096 |
||||
|
||||
EXPORTS |
||||
zlibVersion |
||||
deflate |
||||
deflateEnd |
||||
inflate |
||||
inflateEnd |
||||
deflateSetDictionary |
||||
deflateCopy |
||||
deflateReset |
||||
deflateParams |
||||
inflateSetDictionary |
||||
inflateSync |
||||
inflateReset |
||||
compress |
||||
uncompress |
||||
gzopen |
||||
gzdopen |
||||
gzread |
||||
gzwrite |
||||
gzflush |
||||
gzclose |
||||
gzerror |
||||
adler32 |
||||
crc32 |
||||
deflateInit_ |
||||
inflateInit_ |
||||
deflateInit2_ |
||||
inflateInit2_ |
||||
Loading…
Reference in new issue